Header And Logo

PostgreSQL
| The world's most advanced open source database.

Data Structures | Functions | Variables

pg_dump.c File Reference

#include "postgres_fe.h"
#include <unistd.h>
#include <ctype.h>
#include "getopt_long.h"
#include "access/attnum.h"
#include "access/sysattr.h"
#include "access/transam.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_class.h"
#include "catalog/pg_default_acl.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_largeobject.h"
#include "catalog/pg_largeobject_metadata.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "libpq/libpq-fs.h"
#include "pg_backup_archiver.h"
#include "pg_backup_db.h"
#include "pg_backup_utils.h"
#include "dumputils.h"
#include "parallel.h"
Include dependency graph for pg_dump.c:

Go to the source code of this file.

Data Structures

struct  CommentItem
struct  SecLabelItem

Functions

static void help (const char *progname)
static void setup_connection (Archive *AH, const char *dumpencoding, char *use_role)
static ArchiveFormat parseArchiveFormat (const char *format, ArchiveMode *mode)
static void expand_schema_name_patterns (Archive *fout, SimpleStringList *patterns, SimpleOidList *oids)
static void expand_table_name_patterns (Archive *fout, SimpleStringList *patterns, SimpleOidList *oids)
static NamespaceInfofindNamespace (Archive *fout, Oid nsoid, Oid objoid)
static void dumpTableData (Archive *fout, TableDataInfo *tdinfo)
static void refreshMatViewData (Archive *fout, TableDataInfo *tdinfo)
static void guessConstraintInheritance (TableInfo *tblinfo, int numTables)
static void dumpComment (Archive *fout, const char *target, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId)
static int findComments (Archive *fout, Oid classoid, Oid objoid, CommentItem **items)
static int collectComments (Archive *fout, CommentItem **items)
static void dumpSecLabel (Archive *fout, const char *target, const char *namespace, const char *owner, CatalogId catalogId, int subid, DumpId dumpId)
static int findSecLabels (Archive *fout, Oid classoid, Oid objoid, SecLabelItem **items)
static int collectSecLabels (Archive *fout, SecLabelItem **items)
static void dumpDumpableObject (Archive *fout, DumpableObject *dobj)
static void dumpNamespace (Archive *fout, NamespaceInfo *nspinfo)
static void dumpExtension (Archive *fout, ExtensionInfo *extinfo)
static void dumpType (Archive *fout, TypeInfo *tyinfo)
static void dumpBaseType (Archive *fout, TypeInfo *tyinfo)
static void dumpEnumType (Archive *fout, TypeInfo *tyinfo)
static void dumpRangeType (Archive *fout, TypeInfo *tyinfo)
static void dumpDomain (Archive *fout, TypeInfo *tyinfo)
static void dumpCompositeType (Archive *fout, TypeInfo *tyinfo)
static void dumpCompositeTypeColComments (Archive *fout, TypeInfo *tyinfo)
static void dumpShellType (Archive *fout, ShellTypeInfo *stinfo)
static void dumpProcLang (Archive *fout, ProcLangInfo *plang)
static void dumpFunc (Archive *fout, FuncInfo *finfo)
static void dumpCast (Archive *fout, CastInfo *cast)
static void dumpOpr (Archive *fout, OprInfo *oprinfo)
static void dumpOpclass (Archive *fout, OpclassInfo *opcinfo)
static void dumpOpfamily (Archive *fout, OpfamilyInfo *opfinfo)
static void dumpCollation (Archive *fout, CollInfo *convinfo)
static void dumpConversion (Archive *fout, ConvInfo *convinfo)
static void dumpRule (Archive *fout, RuleInfo *rinfo)
static void dumpAgg (Archive *fout, AggInfo *agginfo)
static void dumpTrigger (Archive *fout, TriggerInfo *tginfo)
static void dumpEventTrigger (Archive *fout, EventTriggerInfo *evtinfo)
static void dumpTable (Archive *fout, TableInfo *tbinfo)
static void dumpTableSchema (Archive *fout, TableInfo *tbinfo)
static void dumpAttrDef (Archive *fout, AttrDefInfo *adinfo)
static void dumpSequence (Archive *fout, TableInfo *tbinfo)
static void dumpSequenceData (Archive *fout, TableDataInfo *tdinfo)
static void dumpIndex (Archive *fout, IndxInfo *indxinfo)
static void dumpConstraint (Archive *fout, ConstraintInfo *coninfo)
static void dumpTableConstraintComment (Archive *fout, ConstraintInfo *coninfo)
static void dumpTSParser (Archive *fout, TSParserInfo *prsinfo)
static void dumpTSDictionary (Archive *fout, TSDictInfo *dictinfo)
static void dumpTSTemplate (Archive *fout, TSTemplateInfo *tmplinfo)
static void dumpTSConfig (Archive *fout, TSConfigInfo *cfginfo)
static void dumpForeignDataWrapper (Archive *fout, FdwInfo *fdwinfo)
static void dumpForeignServer (Archive *fout, 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, DefaultACLInfo *daclinfo)
static void dumpACL (Archive *fout, CatalogId objCatId, DumpId objDumpId, const char *type, const char *name, const char *subname, const char *tag, const char *nspname, const char *owner, const char *acls)
static void getDependencies (Archive *fout)
static void BuildArchiveDependencies (Archive *fout)
static void findDumpableDependencies (ArchiveHandle *AH, DumpableObject *dobj, DumpId **dependencies, int *nDeps, int *allocDeps)
static DumpableObjectcreateBoundaryObjects (void)
static void addBoundaryDependencies (DumpableObject **dobjs, int numObjs, DumpableObject *boundaryObjs)
static void getDomainConstraints (Archive *fout, TypeInfo *tyinfo)
static void getTableData (TableInfo *tblinfo, int numTables, bool oids)
static void makeTableDataInfo (TableInfo *tbinfo, bool oids)
static void buildMatViewRefreshDependencies (Archive *fout)
static void getTableDataFKConstraints (void)
static char * format_function_arguments (FuncInfo *finfo, char *funcargs)
static char * format_function_arguments_old (Archive *fout, FuncInfo *finfo, int nallargs, char **allargtypes, char **argmodes, char **argnames)
static char * format_function_signature (Archive *fout, FuncInfo *finfo, bool honor_quotes)
static const char * convertRegProcReference (Archive *fout, const char *proc)
static const char * convertOperatorReference (Archive *fout, const char *opr)
static const char * convertTSFunction (Archive *fout, Oid funcOid)
static Oid findLastBuiltinOid_V71 (Archive *fout, const char *)
static Oid findLastBuiltinOid_V70 (Archive *fout)
static void selectSourceSchema (Archive *fout, const char *schemaName)
static char * getFormattedTypeName (Archive *fout, Oid oid, OidOptions opts)
static char * myFormatType (const char *typname, int32 typmod)
static void getBlobs (Archive *fout)
static void dumpBlob (Archive *fout, BlobInfo *binfo)
static int dumpBlobs (Archive *fout, void *arg)
static void dumpDatabase (Archive *AH)
static void dumpEncoding (Archive *AH)
static void dumpStdStrings (Archive *AH)
static void binary_upgrade_set_type_oids_by_type_oid (Archive *fout, PQExpBuffer upgrade_buffer, Oid pg_type_oid)
static bool binary_upgrade_set_type_oids_by_rel_oid (Archive *fout, PQExpBuffer upgrade_buffer, Oid pg_rel_oid)
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, DumpableObject *dobj, const char *objlabel)
static const char * getAttrName (int attrnum, TableInfo *tblInfo)
static const char * fmtCopyColumnList (const TableInfo *ti, PQExpBuffer buffer)
static char * get_synchronized_snapshot (Archive *fout)
static PGresultExecuteSqlQueryForSingleRow (Archive *fout, char *query)
static void setupDumpWorker (Archive *AHX, RestoreOptions *ropt)
int main (int argc, char **argv)
static void selectDumpableNamespace (NamespaceInfo *nsinfo)
static void selectDumpableTable (TableInfo *tbinfo)
static void selectDumpableType (TypeInfo *tyinfo)
static void selectDumpableDefaultACL (DefaultACLInfo *dinfo)
static void selectDumpableExtension (ExtensionInfo *extinfo)
static void selectDumpableObject (DumpableObject *dobj)
static int dumpTableData_copy (Archive *fout, void *dcontext)
static int dumpTableData_insert (Archive *fout, void *dcontext)
NamespaceInfogetNamespaces (Archive *fout, int *numNamespaces)
ExtensionInfogetExtensions (Archive *fout, int *numExtensions)
TypeInfogetTypes (Archive *fout, int *numTypes)
OprInfogetOperators (Archive *fout, int *numOprs)
CollInfogetCollations (Archive *fout, int *numCollations)
ConvInfogetConversions (Archive *fout, int *numConversions)
OpclassInfogetOpclasses (Archive *fout, int *numOpclasses)
OpfamilyInfogetOpfamilies (Archive *fout, int *numOpfamilies)
AggInfogetAggregates (Archive *fout, int *numAggs)
FuncInfogetFuncs (Archive *fout, int *numFuncs)
TableInfogetTables (Archive *fout, int *numTables)
void getOwnedSeqs (Archive *fout, TableInfo tblinfo[], int numTables)
InhInfogetInherits (Archive *fout, int *numInherits)
void getIndexes (Archive *fout, TableInfo tblinfo[], int numTables)
void getConstraints (Archive *fout, TableInfo tblinfo[], int numTables)
RuleInfogetRules (Archive *fout, int *numRules)
void getTriggers (Archive *fout, TableInfo tblinfo[], int numTables)
EventTriggerInfogetEventTriggers (Archive *fout, int *numEventTriggers)
ProcLangInfogetProcLangs (Archive *fout, int *numProcLangs)
CastInfogetCasts (Archive *fout, int *numCasts)
void getTableAttrs (Archive *fout, TableInfo *tblinfo, int numTables)
bool shouldPrintColumn (TableInfo *tbinfo, int colno)
TSParserInfogetTSParsers (Archive *fout, int *numTSParsers)
TSDictInfogetTSDictionaries (Archive *fout, int *numTSDicts)
TSTemplateInfogetTSTemplates (Archive *fout, int *numTSTemplates)
TSConfigInfogetTSConfigurations (Archive *fout, int *numTSConfigs)
FdwInfogetForeignDataWrappers (Archive *fout, int *numForeignDataWrappers)
ForeignServerInfogetForeignServers (Archive *fout, int *numForeignServers)
DefaultACLInfogetDefaultACLs (Archive *fout, int *numDefaultACLs)
static void dumpTableComment (Archive *fout, TableInfo *tbinfo, const char *reltypename)
static bool shouldDumpProcLangs (void)
static char * format_aggregate_signature (AggInfo *agginfo, Archive *fout, bool honor_quotes)
static void dumpTableSecLabel (Archive *fout, TableInfo *tbinfo, const char *reltypename)
static PQExpBuffer createViewAsClause (Archive *fout, TableInfo *tbinfo)
void getExtensionMembership (Archive *fout, ExtensionInfo extinfo[], int numExtensions)

Variables

char * optarg
int optind
int opterr
bool g_verbose
bool schemaOnly
bool dataOnly
int dumpSections
bool aclsSkip
const char * lockWaitTimeout
static const char * username_subquery
static Oid g_last_builtin_oid
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 SimpleOidList table_include_oids = {NULL, NULL}
static SimpleStringList table_exclude_patterns = {NULL, NULL}
static SimpleOidList table_exclude_oids = {NULL, NULL}
static SimpleStringList tabledata_exclude_patterns = {NULL, NULL}
static SimpleOidList tabledata_exclude_oids = {NULL, NULL}
static bool include_everything = true
char g_opaque_type [10]
char g_comment_start [10]
char g_comment_end [10]
static const CatalogId nilCatalogId = {0, 0}
static int binary_upgrade = 0
static int disable_dollar_quoting = 0
static int dump_inserts = 0
static int column_inserts = 0
static int no_security_labels = 0
static int no_synchronized_snapshots = 0
static int no_unlogged_table_data = 0
static int serializable_deferrable = 0

Function Documentation

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

Definition at line 14842 of file pg_dump.c.

References addObjectDependency(), DO_AGG, DO_ATTRDEF, DO_BLOB, DO_BLOB_DATA, 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_NAMESPACE, DO_OPCLASS, DO_OPERATOR, DO_OPFAMILY, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, DO_PROCLANG, DO_REFRESH_MATVIEW, DO_RULE, DO_SHELL_TYPE, DO_TABLE, DO_TABLE_DATA, DO_TRIGGER, DO_TSCONFIG, DO_TSDICT, DO_TSPARSER, DO_TSTEMPLATE, DO_TYPE, _dumpableObject::dumpId, i, and _dumpableObject::objType.

Referenced by main().

{
    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_OPCLASS:
            case DO_OPFAMILY:
            case DO_COLLATION:
            case DO_CONVERSION:
            case DO_TABLE:
            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_BLOB:
                /* Pre-data objects: must come before the pre-data boundary */
                addObjectDependency(preDataBound, dobj->dumpId);
                break;
            case DO_TABLE_DATA:
            case DO_BLOB_DATA:
                /* Data objects: must come between the boundaries */
                addObjectDependency(dobj, preDataBound->dumpId);
                addObjectDependency(postDataBound, dobj->dumpId);
                break;
            case DO_INDEX:
            case DO_REFRESH_MATVIEW:
            case DO_TRIGGER:
            case DO_EVENT_TRIGGER:
            case DO_DEFAULT_ACL:
                /* 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;
        }
    }
}

static void binary_upgrade_extension_member ( PQExpBuffer  upgrade_buffer,
DumpableObject dobj,
const char *  objlabel 
) [static]

Definition at line 2840 of file pg_dump.c.

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

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

{
    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)
        exit_horribly(NULL, "could not find parent extension for %s\n", objlabel);

    appendPQExpBuffer(upgrade_buffer,
      "\n-- For binary upgrade, handle extension membership the hard way\n");
    appendPQExpBuffer(upgrade_buffer, "ALTER EXTENSION %s ADD %s;\n",
                      fmtId(extobj->name),
                      objlabel);
}

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

Definition at line 2773 of file pg_dump.c.

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

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

{
    PQExpBuffer upgrade_query = createPQExpBuffer();
    PGresult   *upgrade_res;
    Oid         pg_class_reltoastrelid;
    Oid         pg_class_reltoastidxid;

    appendPQExpBuffer(upgrade_query,
                      "SELECT c.reltoastrelid, t.reltoastidxid "
                      "FROM pg_catalog.pg_class c LEFT JOIN "
                      "pg_catalog.pg_class t ON (c.reltoastrelid = t.oid) "
                      "WHERE c.oid = '%u'::pg_catalog.oid;",
                      pg_class_oid);

    upgrade_res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);

    pg_class_reltoastrelid = atooid(PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "reltoastrelid")));
    pg_class_reltoastidxid = atooid(PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "reltoastidxid")));

    appendPQExpBuffer(upgrade_buffer,
                   "\n-- For binary upgrade, must preserve pg_class oids\n");

    if (!is_index)
    {
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT binary_upgrade.set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
                          pg_class_oid);
        /* only tables have toast tables, not indexes */
        if (OidIsValid(pg_class_reltoastrelid))
        {
            /*
             * One complexity is that the table definition might not require
             * the creation of a TOAST table, and the TOAST table might have
             * been created long after table creation, when the table was
             * loaded with wide data.  By setting the TOAST oid we force
             * creation of the TOAST heap and TOAST index by the backend so we
             * can cleanly copy the files during binary upgrade.
             */

            appendPQExpBuffer(upgrade_buffer,
                              "SELECT binary_upgrade.set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
                              pg_class_reltoastrelid);

            /* every toast table has an index */
            appendPQExpBuffer(upgrade_buffer,
                              "SELECT binary_upgrade.set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
                              pg_class_reltoastidxid);
        }
    }
    else
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT binary_upgrade.set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
                          pg_class_oid);

    appendPQExpBuffer(upgrade_buffer, "\n");

    PQclear(upgrade_res);
    destroyPQExpBuffer(upgrade_query);
}

static bool binary_upgrade_set_type_oids_by_rel_oid ( Archive fout,
PQExpBuffer  upgrade_buffer,
Oid  pg_rel_oid 
) [static]

Definition at line 2727 of file pg_dump.c.

References appendPQExpBuffer(), atooid, binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), PQclear(), PQfnumber(), PQgetisnull(), and PQgetvalue().

Referenced by dumpSequence(), and dumpTableSchema().

{
    PQExpBuffer upgrade_query = createPQExpBuffer();
    PGresult   *upgrade_res;
    Oid         pg_type_oid;
    bool        toast_set = false;

    /* we only support old >= 8.3 for binary upgrades */
    appendPQExpBuffer(upgrade_query,
                      "SELECT c.reltype AS crel, t.reltype AS trel "
                      "FROM pg_catalog.pg_class c "
                      "LEFT JOIN pg_catalog.pg_class t ON "
                      "  (c.reltoastrelid = t.oid) "
                      "WHERE c.oid = '%u'::pg_catalog.oid;",
                      pg_rel_oid);

    upgrade_res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);

    pg_type_oid = atooid(PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "crel")));

    binary_upgrade_set_type_oids_by_type_oid(fout, upgrade_buffer,
                                             pg_type_oid);

    if (!PQgetisnull(upgrade_res, 0, PQfnumber(upgrade_res, "trel")))
    {
        /* Toast tables do not have pg_type array rows */
        Oid         pg_type_toast_oid = atooid(PQgetvalue(upgrade_res, 0,
                                            PQfnumber(upgrade_res, "trel")));

        appendPQExpBuffer(upgrade_buffer, "\n-- For binary upgrade, must preserve pg_type toast oid\n");
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT binary_upgrade.set_next_toast_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                          pg_type_toast_oid);

        toast_set = true;
    }

    PQclear(upgrade_res);
    destroyPQExpBuffer(upgrade_query);

    return toast_set;
}

static void binary_upgrade_set_type_oids_by_type_oid ( Archive fout,
PQExpBuffer  upgrade_buffer,
Oid  pg_type_oid 
) [static]

Definition at line 2689 of file pg_dump.c.

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

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

{
    PQExpBuffer upgrade_query = createPQExpBuffer();
    PGresult   *upgrade_res;
    Oid         pg_type_array_oid;

    appendPQExpBuffer(upgrade_buffer, "\n-- For binary upgrade, must preserve pg_type oid\n");
    appendPQExpBuffer(upgrade_buffer,
     "SELECT binary_upgrade.set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                      pg_type_oid);

    /* we only support old >= 8.3 for binary upgrades */
    appendPQExpBuffer(upgrade_query,
                      "SELECT typarray "
                      "FROM pg_catalog.pg_type "
                      "WHERE pg_type.oid = '%u'::pg_catalog.oid;",
                      pg_type_oid);

    upgrade_res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);

    pg_type_array_oid = atooid(PQgetvalue(upgrade_res, 0, PQfnumber(upgrade_res, "typarray")));

    if (OidIsValid(pg_type_array_oid))
    {
        appendPQExpBuffer(upgrade_buffer,
               "\n-- For binary upgrade, must preserve pg_type array oid\n");
        appendPQExpBuffer(upgrade_buffer,
                          "SELECT binary_upgrade.set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
                          pg_type_array_oid);
    }

    PQclear(upgrade_res);
    destroyPQExpBuffer(upgrade_query);
}

static void BuildArchiveDependencies ( Archive fout  )  [static]

Definition at line 14946 of file pg_dump.c.

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

Referenced by main().

{
    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);
    }
}

static void buildMatViewRefreshDependencies ( Archive fout  )  [static]

Definition at line 1875 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), Assert, atooid, createPQExpBuffer(), PQExpBufferData::data, _tableInfo::dataObj, destroyPQExpBuffer(), DO_REFRESH_MATVIEW, DO_TABLE, _dumpableObject::dumpId, ExecuteSqlQuery(), findObjectByCatalogId(), i, _tableInfo::isscannable, NULL, _dumpableObject::objType, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _tableInfo::relkind, RELKIND_MATVIEW, Archive::remoteVersion, selectSourceSchema(), and CatalogId::tableoid.

Referenced by main().

{
    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;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    query = createPQExpBuffer();

    appendPQExpBuffer(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 = 'm' "
                      "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 ('m','v') "
                      "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 ('m','v') "
                      ") "
              "select 'pg_class'::regclass::oid as classid, objid, refobjid "
                      "from w "
                      "where refrelkind = 'm'");

    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->isscannable)
            tbinfo->isscannable = false;
    }

    PQclear(res);

    destroyPQExpBuffer(query);
}

static int collectComments ( Archive fout,
CommentItem **  items 
) [static]

Definition at line 7567 of file pg_dump.c.

References appendPQExpBuffer(), atooid, CommentItem::classoid, createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), ExecuteSqlQuery(), i, CommentItem::objoid, CommentItem::objsubid, pg_malloc(), PGRES_TUPLES_OK, PQfnumber(), PQgetvalue(), PQntuples(), and Archive::remoteVersion.

Referenced by findComments().

{
    PGresult   *res;
    PQExpBuffer query;
    int         i_description;
    int         i_classoid;
    int         i_objoid;
    int         i_objsubid;
    int         ntups;
    int         i;
    CommentItem *comments;

    /*
     * Note we do NOT change source schema here; preserve the caller's
     * setting, instead.
     */

    query = createPQExpBuffer();

    if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT description, classoid, objoid, objsubid "
                          "FROM pg_catalog.pg_description "
                          "ORDER BY classoid, objoid, objsubid");
    }
    else if (fout->remoteVersion >= 70200)
    {
        appendPQExpBuffer(query, "SELECT description, classoid, objoid, objsubid "
                          "FROM pg_description "
                          "ORDER BY classoid, objoid, objsubid");
    }
    else
    {
        /* Note: this will fail to find attribute comments in pre-7.2... */
        appendPQExpBuffer(query, "SELECT description, 0 AS classoid, objoid, 0 AS objsubid "
                          "FROM pg_description "
                          "ORDER BY objoid");
    }

    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));

    for (i = 0; i < ntups; i++)
    {
        comments[i].descr = PQgetvalue(res, i, i_description);
        comments[i].classoid = atooid(PQgetvalue(res, i, i_classoid));
        comments[i].objoid = atooid(PQgetvalue(res, i, i_objoid));
        comments[i].objsubid = atoi(PQgetvalue(res, i, i_objsubid));
    }

    /* Do NOT free the PGresult since we are keeping pointers into it */
    destroyPQExpBuffer(query);

    *items = comments;
    return ntups;
}

static int collectSecLabels ( Archive fout,
SecLabelItem **  items 
) [static]

Definition at line 12610 of file pg_dump.c.

References appendPQExpBuffer(), atooid, SecLabelItem::classoid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), i, SecLabelItem::label, SecLabelItem::objoid, SecLabelItem::objsubid, pg_malloc(), PGRES_TUPLES_OK, PQfnumber(), PQgetvalue(), PQntuples(), and SecLabelItem::provider.

Referenced by findSecLabels().

{
    PGresult   *res;
    PQExpBuffer query;
    int         i_label;
    int         i_provider;
    int         i_classoid;
    int         i_objoid;
    int         i_objsubid;
    int         ntups;
    int         i;
    SecLabelItem *labels;

    query = createPQExpBuffer();

    appendPQExpBuffer(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);

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

    for (i = 0; i < ntups; i++)
    {
        labels[i].label = PQgetvalue(res, i, i_label);
        labels[i].provider = PQgetvalue(res, i, i_provider);
        labels[i].classoid = atooid(PQgetvalue(res, i, i_classoid));
        labels[i].objoid = atooid(PQgetvalue(res, i, i_objoid));
        labels[i].objsubid = atoi(PQgetvalue(res, i, i_objsubid));
    }

    /* Do NOT free the PGresult since we are keeping pointers into it */
    destroyPQExpBuffer(query);

    *items = labels;
    return ntups;
}

static const char * convertOperatorReference ( Archive fout,
const char *  opr 
) [static]

Definition at line 10392 of file pg_dump.c.

References atooid, _oprInfo::dobj, findOprByOid(), free, _dumpableObject::name, name, NULL, pg_malloc(), pg_strdup(), Archive::remoteVersion, and write_msg().

Referenced by dumpAgg(), and dumpOpr().

{
    OprInfo    *oprInfo;

    /* In all cases "0" means a null reference */
    if (strcmp(opr, "0") == 0)
        return NULL;

    if (fout->remoteVersion >= 70300)
    {
        char       *name;
        char       *oname;
        char       *ptr;
        bool        inquote;
        bool        sawdot;

        name = pg_strdup(opr);
        /* find non-double-quoted left paren, and check for non-quoted dot */
        inquote = false;
        sawdot = false;
        for (ptr = name; *ptr; ptr++)
        {
            if (*ptr == '"')
                inquote = !inquote;
            else if (*ptr == '.' && !inquote)
                sawdot = true;
            else if (*ptr == '(' && !inquote)
            {
                *ptr = '\0';
                break;
            }
        }
        /* If not schema-qualified, don't need to add OPERATOR() */
        if (!sawdot)
            return name;
        oname = pg_malloc(strlen(name) + 11);
        sprintf(oname, "OPERATOR(%s)", name);
        free(name);
        return oname;
    }

    oprInfo = findOprByOid(atooid(opr));
    if (oprInfo == NULL)
    {
        write_msg(NULL, "WARNING: could not find operator with OID %s\n",
                  opr);
        return NULL;
    }
    return oprInfo->dobj.name;
}

static const char * convertRegProcReference ( Archive fout,
const char *  proc 
) [static]

Definition at line 10349 of file pg_dump.c.

References fmtId(), name, pg_strdup(), and Archive::remoteVersion.

Referenced by dumpOpr().

{
    /* In all cases "-" means a null reference */
    if (strcmp(proc, "-") == 0)
        return NULL;

    if (fout->remoteVersion >= 70300)
    {
        char       *name;
        char       *paren;
        bool        inquote;

        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;
    }

    /* REGPROC before 7.3 does not quote its result */
    return fmtId(proc);
}

static const char * convertTSFunction ( Archive fout,
Oid  funcOid 
) [static]

Definition at line 10452 of file pg_dump.c.

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

Referenced by dumpTSParser(), and dumpTSTemplate().

{
    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;
}

static DumpableObject * createBoundaryObjects ( void   )  [static]

Definition at line 14818 of file pg_dump.c.

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

Referenced by main().

{
    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;
}

static PQExpBuffer createViewAsClause ( Archive fout,
TableInfo tbinfo 
) [static]

Definition at line 12735 of file pg_dump.c.

References appendBinaryPQExpBuffer(), appendPQExpBuffer(), appendStringLiteralAH, Assert, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, ExecuteSqlQuery(), exit_horribly(), _dumpableObject::name, NULL, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQgetlength(), PQgetvalue(), PQntuples(), and Archive::remoteVersion.

Referenced by dumpTableSchema().

{
    PQExpBuffer query = createPQExpBuffer();
    PQExpBuffer result = createPQExpBuffer();
    PGresult   *res;
    int         len;

    /* Fetch the view definition */
    if (fout->remoteVersion >= 70300)
    {
        /* Beginning in 7.3, viewname is not unique; rely on OID */
        appendPQExpBuffer(query,
         "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
                          tbinfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT definition AS viewdef "
                          "FROM pg_views WHERE viewname = ");
        appendStringLiteralAH(query, tbinfo->dobj.name, fout);
        appendPQExpBuffer(query, ";");
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    if (PQntuples(res) != 1)
    {
        if (PQntuples(res) < 1)
            exit_horribly(NULL, "query to obtain definition of view \"%s\" returned no data\n",
                          tbinfo->dobj.name);
        else
            exit_horribly(NULL, "query to obtain definition of view \"%s\" returned more than one definition\n",
                          tbinfo->dobj.name);
    }

    len = PQgetlength(res, 0, 0);

    if (len == 0)
        exit_horribly(NULL, "definition of view \"%s\" appears to be empty (length zero)\n",
                      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;
}

static void dumpACL ( Archive fout,
CatalogId  objCatId,
DumpId  objDumpId,
const char *  type,
const char *  name,
const char *  subname,
const char *  tag,
const char *  nspname,
const char *  owner,
const char *  acls 
) [static]

Definition at line 12324 of file pg_dump.c.

References aclsSkip, ArchiveEntry(), buildACLCommands(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), exit_horribly(), PQExpBufferData::len, NULL, Archive::remoteVersion, and SECTION_NONE.

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

{
    PQExpBuffer sql;

    /* Do nothing if ACL dump is not enabled */
    if (aclsSkip)
        return;

    /* --data-only skips ACLs *except* BLOB ACLs */
    if (dataOnly && strcmp(type, "LARGE OBJECT") != 0)
        return;

    sql = createPQExpBuffer();

    if (!buildACLCommands(name, subname, type, acls, owner,
                          "", fout->remoteVersion, sql))
        exit_horribly(NULL,
                    "could not parse ACL list (%s) for object \"%s\" (%s)\n",
                      acls, name, type);

    if (sql->len > 0)
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     tag, nspname,
                     NULL,
                     owner ? owner : "",
                     false, "ACL", SECTION_NONE,
                     sql->data, "", NULL,
                     &(objDumpId), 1,
                     NULL, NULL);

    destroyPQExpBuffer(sql);
}

static void dumpAgg ( Archive fout,
AggInfo agginfo 
) [static]

Definition at line 11392 of file pg_dump.c.

References _aggInfo::aggfn, appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, convertOperatorReference(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _funcInfo::dobj, _dumpableObject::dump, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), ExecuteSqlQueryForSingleRow(), fmtId(), format_aggregate_signature(), format_function_signature(), free, _dumpableObject::name, NULL, CatalogId::oid, PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), _funcInfo::proacl, Archive::remoteVersion, _funcInfo::rolname, SECTION_PRE_DATA, selectSourceSchema(), and write_msg().

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PQExpBuffer details;
    char       *aggsig;
    char       *aggsig_tag;
    PGresult   *res;
    int         i_aggtransfn;
    int         i_aggfinalfn;
    int         i_aggsortop;
    int         i_aggtranstype;
    int         i_agginitval;
    int         i_convertok;
    const char *aggtransfn;
    const char *aggfinalfn;
    const char *aggsortop;
    const char *aggtranstype;
    const char *agginitval;
    bool        convertok;

    /* Skip if not to be dumped */
    if (!agginfo->aggfn.dobj.dump || dataOnly)
        return;

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();
    details = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, agginfo->aggfn.dobj.namespace->dobj.name);

    /* Get aggregate-specific details */
    if (fout->remoteVersion >= 80100)
    {
        appendPQExpBuffer(query, "SELECT aggtransfn, "
                          "aggfinalfn, aggtranstype::pg_catalog.regtype, "
                          "aggsortop::pg_catalog.regoperator, "
                          "agginitval, "
                          "'t'::boolean AS convertok "
                      "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
                          "WHERE a.aggfnoid = p.oid "
                          "AND p.oid = '%u'::pg_catalog.oid",
                          agginfo->aggfn.dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT aggtransfn, "
                          "aggfinalfn, aggtranstype::pg_catalog.regtype, "
                          "0 AS aggsortop, "
                          "agginitval, "
                          "'t'::boolean AS convertok "
                      "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
                          "WHERE a.aggfnoid = p.oid "
                          "AND p.oid = '%u'::pg_catalog.oid",
                          agginfo->aggfn.dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT aggtransfn, aggfinalfn, "
                          "format_type(aggtranstype, NULL) AS aggtranstype, "
                          "0 AS aggsortop, "
                          "agginitval, "
                          "'t'::boolean AS convertok "
                          "FROM pg_aggregate "
                          "WHERE oid = '%u'::oid",
                          agginfo->aggfn.dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT aggtransfn1 AS aggtransfn, "
                          "aggfinalfn, "
                          "(SELECT typname FROM pg_type WHERE oid = aggtranstype1) AS aggtranstype, "
                          "0 AS aggsortop, "
                          "agginitval1 AS agginitval, "
                          "(aggtransfn2 = 0 and aggtranstype2 = 0 and agginitval2 is null) AS convertok "
                          "FROM pg_aggregate "
                          "WHERE oid = '%u'::oid",
                          agginfo->aggfn.dobj.catId.oid);
    }

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    i_aggtransfn = PQfnumber(res, "aggtransfn");
    i_aggfinalfn = PQfnumber(res, "aggfinalfn");
    i_aggsortop = PQfnumber(res, "aggsortop");
    i_aggtranstype = PQfnumber(res, "aggtranstype");
    i_agginitval = PQfnumber(res, "agginitval");
    i_convertok = PQfnumber(res, "convertok");

    aggtransfn = PQgetvalue(res, 0, i_aggtransfn);
    aggfinalfn = PQgetvalue(res, 0, i_aggfinalfn);
    aggsortop = PQgetvalue(res, 0, i_aggsortop);
    aggtranstype = PQgetvalue(res, 0, i_aggtranstype);
    agginitval = PQgetvalue(res, 0, i_agginitval);
    convertok = (PQgetvalue(res, 0, i_convertok)[0] == 't');

    aggsig = format_aggregate_signature(agginfo, fout, true);
    aggsig_tag = format_aggregate_signature(agginfo, fout, false);

    if (!convertok)
    {
        write_msg(NULL, "WARNING: aggregate function %s could not be dumped correctly for this database version; ignored\n",
                  aggsig);
        return;
    }

    if (fout->remoteVersion >= 70300)
    {
        /* If using 7.3's regproc or regtype, data is already quoted */
        appendPQExpBuffer(details, "    SFUNC = %s,\n    STYPE = %s",
                          aggtransfn,
                          aggtranstype);
    }
    else if (fout->remoteVersion >= 70100)
    {
        /* format_type quotes, regproc does not */
        appendPQExpBuffer(details, "    SFUNC = %s,\n    STYPE = %s",
                          fmtId(aggtransfn),
                          aggtranstype);
    }
    else
    {
        /* need quotes all around */
        appendPQExpBuffer(details, "    SFUNC = %s,\n",
                          fmtId(aggtransfn));
        appendPQExpBuffer(details, "    STYPE = %s",
                          fmtId(aggtranstype));
    }

    if (!PQgetisnull(res, 0, i_agginitval))
    {
        appendPQExpBuffer(details, ",\n    INITCOND = ");
        appendStringLiteralAH(details, agginitval, fout);
    }

    if (strcmp(aggfinalfn, "-") != 0)
    {
        appendPQExpBuffer(details, ",\n    FINALFUNC = %s",
                          aggfinalfn);
    }

    aggsortop = convertOperatorReference(fout, aggsortop);
    if (aggsortop)
    {
        appendPQExpBuffer(details, ",\n    SORTOP = %s",
                          aggsortop);
    }

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP AGGREGATE %s.%s;\n",
                      fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
                      aggsig);

    appendPQExpBuffer(q, "CREATE AGGREGATE %s (\n%s\n);\n",
                      aggsig, details->data);

    appendPQExpBuffer(labelq, "AGGREGATE %s", aggsig);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &agginfo->aggfn.dobj, labelq->data);

    ArchiveEntry(fout, agginfo->aggfn.dobj.catId, agginfo->aggfn.dobj.dumpId,
                 aggsig_tag,
                 agginfo->aggfn.dobj.namespace->dobj.name,
                 NULL,
                 agginfo->aggfn.rolname,
                 false, "AGGREGATE", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Aggregate Comments */
    dumpComment(fout, labelq->data,
            agginfo->aggfn.dobj.namespace->dobj.name, agginfo->aggfn.rolname,
                agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
            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.
     */
    free(aggsig);
    free(aggsig_tag);

    aggsig = format_function_signature(fout, &agginfo->aggfn, true);
    aggsig_tag = format_function_signature(fout, &agginfo->aggfn, false);

    dumpACL(fout, agginfo->aggfn.dobj.catId, agginfo->aggfn.dobj.dumpId,
            "FUNCTION",
            aggsig, NULL, aggsig_tag,
            agginfo->aggfn.dobj.namespace->dobj.name,
            agginfo->aggfn.rolname, agginfo->aggfn.proacl);

    free(aggsig);
    free(aggsig_tag);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(details);
}

static void dumpAttrDef ( Archive fout,
AttrDefInfo adinfo 
) [static]

Definition at line 13379 of file pg_dump.c.

References _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, appendPQExpBuffer(), ArchiveEntry(), _tableInfo::attnames, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _attrDefInfo::dobj, _tableInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, fmtId(), _dumpableObject::name, NULL, _tableInfo::rolname, SECTION_PRE_DATA, and _attrDefInfo::separate.

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = adinfo->adtable;
    int         adnum = adinfo->adnum;
    PQExpBuffer q;
    PQExpBuffer delq;

    /* Skip if table definition not to be dumped */
    if (!tbinfo->dobj.dump || dataOnly)
        return;

    /* Skip if not "separate"; it was dumped in the table's definition */
    if (!adinfo->separate)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();

    appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                      fmtId(tbinfo->dobj.name));
    appendPQExpBuffer(q, "ALTER COLUMN %s SET DEFAULT %s;\n",
                      fmtId(tbinfo->attnames[adnum - 1]),
                      adinfo->adef_expr);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "ALTER TABLE %s.",
                      fmtId(tbinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, "%s ",
                      fmtId(tbinfo->dobj.name));
    appendPQExpBuffer(delq, "ALTER COLUMN %s DROP DEFAULT;\n",
                      fmtId(tbinfo->attnames[adnum - 1]));

    ArchiveEntry(fout, adinfo->dobj.catId, adinfo->dobj.dumpId,
                 tbinfo->attnames[adnum - 1],
                 tbinfo->dobj.namespace->dobj.name,
                 NULL,
                 tbinfo->rolname,
                 false, "DEFAULT", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
}

static void dumpBaseType ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 8240 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ArchiveEntry(), atooid, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), fmtId(), free, getFormattedTypeName(), NULL, OidIsValid, pg_strdup(), PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), Archive::remoteVersion, SECTION_PRE_DATA, selectSourceSchema(), and zeroAsOpaque.

Referenced by dumpType().

{
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    char       *qtypname;
    char       *typlen;
    char       *typinput;
    char       *typoutput;
    char       *typreceive;
    char       *typsend;
    char       *typmodin;
    char       *typmodout;
    char       *typanalyze;
    Oid         typreceiveoid;
    Oid         typsendoid;
    Oid         typmodinoid;
    Oid         typmodoutoid;
    Oid         typanalyzeoid;
    char       *typcategory;
    char       *typispreferred;
    char       *typdelim;
    char       *typbyval;
    char       *typalign;
    char       *typstorage;
    char       *typcollatable;
    char       *typdefault;
    bool        typdefault_is_literal = false;

    /* Set proper schema search path so regproc references list correctly */
    selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);

    /* Fetch type-specific details */
    if (fout->remoteVersion >= 90100)
    {
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, typreceive, typsend, "
                          "typmodin, typmodout, typanalyze, "
                          "typreceive::pg_catalog.oid AS typreceiveoid, "
                          "typsend::pg_catalog.oid AS typsendoid, "
                          "typmodin::pg_catalog.oid AS typmodinoid, "
                          "typmodout::pg_catalog.oid AS typmodoutoid, "
                          "typanalyze::pg_catalog.oid AS typanalyzeoid, "
                          "typcategory, typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "(typcollation <> 0) AS typcollatable, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, typreceive, typsend, "
                          "typmodin, typmodout, typanalyze, "
                          "typreceive::pg_catalog.oid AS typreceiveoid, "
                          "typsend::pg_catalog.oid AS typsendoid, "
                          "typmodin::pg_catalog.oid AS typmodinoid, "
                          "typmodout::pg_catalog.oid AS typmodoutoid, "
                          "typanalyze::pg_catalog.oid AS typanalyzeoid, "
                          "typcategory, typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80300)
    {
        /* Before 8.4, pg_get_expr does not allow 0 for its second arg */
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, typreceive, typsend, "
                          "typmodin, typmodout, typanalyze, "
                          "typreceive::pg_catalog.oid AS typreceiveoid, "
                          "typsend::pg_catalog.oid AS typsendoid, "
                          "typmodin::pg_catalog.oid AS typmodinoid, "
                          "typmodout::pg_catalog.oid AS typmodoutoid, "
                          "typanalyze::pg_catalog.oid AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80000)
    {
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, typreceive, typsend, "
                          "'-' AS typmodin, '-' AS typmodout, "
                          "typanalyze, "
                          "typreceive::pg_catalog.oid AS typreceiveoid, "
                          "typsend::pg_catalog.oid AS typsendoid, "
                          "0 AS typmodinoid, 0 AS typmodoutoid, "
                          "typanalyze::pg_catalog.oid AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70400)
    {
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, typreceive, typsend, "
                          "'-' AS typmodin, '-' AS typmodout, "
                          "'-' AS typanalyze, "
                          "typreceive::pg_catalog.oid AS typreceiveoid, "
                          "typsend::pg_catalog.oid AS typsendoid, "
                          "0 AS typmodinoid, 0 AS typmodoutoid, "
                          "0 AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, "
                          "'-' AS typreceive, '-' AS typsend, "
                          "'-' AS typmodin, '-' AS typmodout, "
                          "'-' AS typanalyze, "
                          "0 AS typreceiveoid, 0 AS typsendoid, "
                          "0 AS typmodinoid, 0 AS typmodoutoid, "
                          "0 AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70200)
    {
        /*
         * Note: although pre-7.3 catalogs contain typreceive and typsend,
         * ignore them because they are not right.
         */
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, "
                          "'-' AS typreceive, '-' AS typsend, "
                          "'-' AS typmodin, '-' AS typmodout, "
                          "'-' AS typanalyze, "
                          "0 AS typreceiveoid, 0 AS typsendoid, "
                          "0 AS typmodinoid, 0 AS typmodoutoid, "
                          "0 AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "NULL AS typdefaultbin, typdefault "
                          "FROM pg_type "
                          "WHERE oid = '%u'::oid",
                          tyinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70100)
    {
        /*
         * Ignore pre-7.2 typdefault; the field exists but has an unusable
         * representation.
         */
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, "
                          "'-' AS typreceive, '-' AS typsend, "
                          "'-' AS typmodin, '-' AS typmodout, "
                          "'-' AS typanalyze, "
                          "0 AS typreceiveoid, 0 AS typsendoid, "
                          "0 AS typmodinoid, 0 AS typmodoutoid, "
                          "0 AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, typstorage, "
                          "false AS typcollatable, "
                          "NULL AS typdefaultbin, NULL AS typdefault "
                          "FROM pg_type "
                          "WHERE oid = '%u'::oid",
                          tyinfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT typlen, "
                          "typinput, typoutput, "
                          "'-' AS typreceive, '-' AS typsend, "
                          "'-' AS typmodin, '-' AS typmodout, "
                          "'-' AS typanalyze, "
                          "0 AS typreceiveoid, 0 AS typsendoid, "
                          "0 AS typmodinoid, 0 AS typmodoutoid, "
                          "0 AS typanalyzeoid, "
                          "'U' AS typcategory, false AS typispreferred, "
                          "typdelim, typbyval, typalign, "
                          "'p'::char AS typstorage, "
                          "false AS typcollatable, "
                          "NULL AS typdefaultbin, NULL AS typdefault "
                          "FROM pg_type "
                          "WHERE oid = '%u'::oid",
                          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"));
    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")));
    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));

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog.
     * 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.",
                      fmtId(tyinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, "%s CASCADE;\n",
                      qtypname);

    /* We might already have a shell type, but setting pg_type_oid is harmless */
    if (binary_upgrade)
        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                                 tyinfo->dobj.catId.oid);

    appendPQExpBuffer(q,
                      "CREATE TYPE %s (\n"
                      "    INTERNALLENGTH = %s",
                      qtypname,
                      (strcmp(typlen, "-1") == 0) ? "variable" : typlen);

    if (fout->remoteVersion >= 70300)
    {
        /* regproc result is correctly quoted as of 7.3 */
        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);
    }
    else
    {
        /* regproc delivers an unquoted name before 7.3 */
        /* cannot combine these because fmtId uses static result area */
        appendPQExpBuffer(q, ",\n    INPUT = %s", fmtId(typinput));
        appendPQExpBuffer(q, ",\n    OUTPUT = %s", fmtId(typoutput));
        /* receive/send/typmodin/typmodout/analyze need not be printed */
    }

    if (strcmp(typcollatable, "t") == 0)
        appendPQExpBuffer(q, ",\n    COLLATABLE = true");

    if (typdefault != NULL)
    {
        appendPQExpBuffer(q, ",\n    DEFAULT = ");
        if (typdefault_is_literal)
            appendStringLiteralAH(q, typdefault, fout);
        else
            appendPQExpBufferStr(q, typdefault);
    }

    if (OidIsValid(tyinfo->typelem))
    {
        char       *elemType;

        /* reselect schema in case changed by function dump */
        selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
        elemType = getFormattedTypeName(fout, tyinfo->typelem, zeroAsOpaque);
        appendPQExpBuffer(q, ",\n    ELEMENT = %s", elemType);
        free(elemType);
    }

    if (strcmp(typcategory, "U") != 0)
    {
        appendPQExpBuffer(q, ",\n    CATEGORY = ");
        appendStringLiteralAH(q, typcategory, fout);
    }

    if (strcmp(typispreferred, "t") == 0)
        appendPQExpBuffer(q, ",\n    PREFERRED = true");

    if (typdelim && strcmp(typdelim, ",") != 0)
    {
        appendPQExpBuffer(q, ",\n    DELIMITER = ");
        appendStringLiteralAH(q, typdelim, fout);
    }

    if (strcmp(typalign, "c") == 0)
        appendPQExpBuffer(q, ",\n    ALIGNMENT = char");
    else if (strcmp(typalign, "s") == 0)
        appendPQExpBuffer(q, ",\n    ALIGNMENT = int2");
    else if (strcmp(typalign, "i") == 0)
        appendPQExpBuffer(q, ",\n    ALIGNMENT = int4");
    else if (strcmp(typalign, "d") == 0)
        appendPQExpBuffer(q, ",\n    ALIGNMENT = double");

    if (strcmp(typstorage, "p") == 0)
        appendPQExpBuffer(q, ",\n    STORAGE = plain");
    else if (strcmp(typstorage, "e") == 0)
        appendPQExpBuffer(q, ",\n    STORAGE = external");
    else if (strcmp(typstorage, "x") == 0)
        appendPQExpBuffer(q, ",\n    STORAGE = extended");
    else if (strcmp(typstorage, "m") == 0)
        appendPQExpBuffer(q, ",\n    STORAGE = main");

    if (strcmp(typbyval, "t") == 0)
        appendPQExpBuffer(q, ",\n    PASSEDBYVALUE");

    appendPQExpBuffer(q, "\n);\n");

    appendPQExpBuffer(labelq, "TYPE %s", qtypname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);

    ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                 tyinfo->dobj.name,
                 tyinfo->dobj.namespace->dobj.name,
                 NULL,
                 tyinfo->rolname, false,
                 "TYPE", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Type Comments and Security Labels */
    dumpComment(fout, labelq->data,
                tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                 tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);

    dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
            qtypname, NULL, tyinfo->dobj.name,
            tyinfo->dobj.namespace->dobj.name,
            tyinfo->rolname, tyinfo->typacl);

    PQclear(res);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);
}

static void dumpBlob ( Archive fout,
BlobInfo binfo 
) [static]

Definition at line 2561 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), _blobInfo::blobacl, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _blobInfo::dobj, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), _dumpableObject::name, NULL, resetPQExpBuffer(), _blobInfo::rolname, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer cquery = createPQExpBuffer();
    PQExpBuffer dquery = createPQExpBuffer();

    appendPQExpBuffer(cquery,
                      "SELECT pg_catalog.lo_create('%s');\n",
                      binfo->dobj.name);

    appendPQExpBuffer(dquery,
                      "SELECT pg_catalog.lo_unlink('%s');\n",
                      binfo->dobj.name);

    ArchiveEntry(fout, binfo->dobj.catId, binfo->dobj.dumpId,
                 binfo->dobj.name,
                 NULL, NULL,
                 binfo->rolname, false,
                 "BLOB", SECTION_PRE_DATA,
                 cquery->data, dquery->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* set up tag for comment and/or ACL */
    resetPQExpBuffer(cquery);
    appendPQExpBuffer(cquery, "LARGE OBJECT %s", binfo->dobj.name);

    /* Dump comment if any */
    dumpComment(fout, cquery->data,
                NULL, binfo->rolname,
                binfo->dobj.catId, 0, binfo->dobj.dumpId);

    /* Dump security label if any */
    dumpSecLabel(fout, cquery->data,
                 NULL, binfo->rolname,
                 binfo->dobj.catId, 0, binfo->dobj.dumpId);

    /* Dump ACL if any */
    if (binfo->blobacl)
        dumpACL(fout, binfo->dobj.catId, binfo->dobj.dumpId, "LARGE OBJECT",
                binfo->dobj.name, NULL, cquery->data,
                NULL, binfo->rolname, binfo->blobacl);

    destroyPQExpBuffer(cquery);
    destroyPQExpBuffer(dquery);
}

static int dumpBlobs ( Archive fout,
void *  arg 
) [static]

Definition at line 2612 of file pg_dump.c.

References atooid, buf, conn, EndBlob(), ExecuteSqlQuery(), ExecuteSqlStatement(), exit_horribly(), g_verbose, GetConnection(), i, INV_READ, lo_close(), lo_open(), lo_read(), LOBBUFSIZE, NULL, PGRES_TUPLES_OK, PQclear(), PQerrorMessage(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectSourceSchema(), StartBlob(), write_msg(), and WriteData().

Referenced by dumpDumpableObject().

{
    const char *blobQry;
    const char *blobFetchQry;
    PGconn     *conn = GetConnection(fout);
    PGresult   *res;
    char        buf[LOBBUFSIZE];
    int         ntups;
    int         i;
    int         cnt;

    if (g_verbose)
        write_msg(NULL, "saving large objects\n");

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /*
     * Currently, we re-fetch all BLOB OIDs using a cursor.  Consider scanning
     * the already-in-memory dumpable objects instead...
     */
    if (fout->remoteVersion >= 90000)
        blobQry = "DECLARE bloboid CURSOR FOR SELECT oid FROM pg_largeobject_metadata";
    else if (fout->remoteVersion >= 70100)
        blobQry = "DECLARE bloboid CURSOR FOR SELECT DISTINCT loid FROM pg_largeobject";
    else
        blobQry = "DECLARE bloboid CURSOR FOR SELECT oid FROM pg_class WHERE relkind = 'l'";

    ExecuteSqlStatement(fout, blobQry);

    /* Command to fetch from cursor */
    blobFetchQry = "FETCH 1000 IN bloboid";

    do
    {
        /* Do a fetch */
        res = ExecuteSqlQuery(fout, blobFetchQry, PGRES_TUPLES_OK);

        /* Process the tuples, if any */
        ntups = PQntuples(res);
        for (i = 0; i < ntups; i++)
        {
            Oid         blobOid;
            int         loFd;

            blobOid = atooid(PQgetvalue(res, i, 0));
            /* Open the BLOB */
            loFd = lo_open(conn, blobOid, INV_READ);
            if (loFd == -1)
                exit_horribly(NULL, "could not open large object %u: %s",
                              blobOid, PQerrorMessage(conn));

            StartBlob(fout, blobOid);

            /* Now read it in chunks, sending data to archive */
            do
            {
                cnt = lo_read(conn, loFd, buf, LOBBUFSIZE);
                if (cnt < 0)
                    exit_horribly(NULL, "error reading large object %u: %s",
                                  blobOid, PQerrorMessage(conn));

                WriteData(fout, buf, cnt);
            } while (cnt > 0);

            lo_close(conn, loFd);

            EndBlob(fout, blobOid);
        }

        PQclear(res);
    } while (ntups > 0);

    return 1;
}

static void dumpCast ( Archive fout,
CastInfo cast 
) [static]

Definition at line 9958 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _castInfo::castcontext, _castInfo::castfunc, _castInfo::castmethod, _castInfo::castsource, _castInfo::casttarget, _dumpableObject::catId, COERCION_METHOD_BINARY, COERCION_METHOD_FUNCTION, COERCION_METHOD_INOUT, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _funcInfo::dobj, _castInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, _dumpableObject::ext_member, findFuncByOid(), findTypeByOid(), fmtId(), format_function_signature(), free, getFormattedTypeName(), _dumpableObject::name, NULL, OidIsValid, SECTION_PRE_DATA, selectSourceSchema(), write_msg(), and zeroAsNone.

Referenced by dumpDumpableObject().

{
    PQExpBuffer defqry;
    PQExpBuffer delqry;
    PQExpBuffer labelq;
    FuncInfo   *funcInfo = NULL;

    /* Skip if not to be dumped */
    if (!cast->dobj.dump || 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)
            return;
    }

    /*
     * As per discussion we dump casts if one or more of the underlying
     * objects (the conversion function and the two data types) are not
     * builtin AND if all of the non-builtin objects are included in the dump.
     * Builtin meaning, the namespace name does not start with "pg_".
     *
     * However, for a cast that belongs to an extension, we must not use this
     * heuristic, but just dump the cast iff we're told to (via dobj.dump).
     */
    if (!cast->dobj.ext_member)
    {
        TypeInfo   *sourceInfo = findTypeByOid(cast->castsource);
        TypeInfo   *targetInfo = findTypeByOid(cast->casttarget);

        if (sourceInfo == NULL || targetInfo == NULL)
            return;

        /*
         * Skip this cast if all objects are from pg_
         */
        if ((funcInfo == NULL ||
             strncmp(funcInfo->dobj.namespace->dobj.name, "pg_", 3) == 0) &&
            strncmp(sourceInfo->dobj.namespace->dobj.name, "pg_", 3) == 0 &&
            strncmp(targetInfo->dobj.namespace->dobj.name, "pg_", 3) == 0)
            return;

        /*
         * Skip cast if function isn't from pg_ and is not to be dumped.
         */
        if (funcInfo &&
            strncmp(funcInfo->dobj.namespace->dobj.name, "pg_", 3) != 0 &&
            !funcInfo->dobj.dump)
            return;

        /*
         * Same for the source type
         */
        if (strncmp(sourceInfo->dobj.namespace->dobj.name, "pg_", 3) != 0 &&
            !sourceInfo->dobj.dump)
            return;

        /*
         * and the target type.
         */
        if (strncmp(targetInfo->dobj.namespace->dobj.name, "pg_", 3) != 0 &&
            !targetInfo->dobj.dump)
            return;
    }

    /* Make sure we are in proper schema (needed for getFormattedTypeName) */
    selectSourceSchema(fout, "pg_catalog");

    defqry = createPQExpBuffer();
    delqry = createPQExpBuffer();
    labelq = createPQExpBuffer();

    appendPQExpBuffer(delqry, "DROP CAST (%s AS %s);\n",
                    getFormattedTypeName(fout, cast->castsource, zeroAsNone),
                   getFormattedTypeName(fout, cast->casttarget, zeroAsNone));

    appendPQExpBuffer(defqry, "CREATE CAST (%s AS %s) ",
                    getFormattedTypeName(fout, cast->castsource, zeroAsNone),
                   getFormattedTypeName(fout, cast->casttarget, zeroAsNone));

    switch (cast->castmethod)
    {
        case COERCION_METHOD_BINARY:
            appendPQExpBuffer(defqry, "WITHOUT FUNCTION");
            break;
        case COERCION_METHOD_INOUT:
            appendPQExpBuffer(defqry, "WITH INOUT");
            break;
        case COERCION_METHOD_FUNCTION:
            if (funcInfo)
            {
                char       *fsig = format_function_signature(fout, funcInfo, true);

                /*
                 * Always qualify the function name, in case it is not in
                 * pg_catalog schema (format_function_signature won't qualify
                 * it).
                 */
                appendPQExpBuffer(defqry, "WITH FUNCTION %s.%s",
                           fmtId(funcInfo->dobj.namespace->dobj.name), fsig);
                free(fsig);
            }
            else
                write_msg(NULL, "WARNING: bogus value in pg_cast.castfunc or pg_cast.castmethod field\n");
            break;
        default:
            write_msg(NULL, "WARNING: bogus value in pg_cast.castmethod field\n");
    }

    if (cast->castcontext == 'a')
        appendPQExpBuffer(defqry, " AS ASSIGNMENT");
    else if (cast->castcontext == 'i')
        appendPQExpBuffer(defqry, " AS IMPLICIT");
    appendPQExpBuffer(defqry, ";\n");

    appendPQExpBuffer(labelq, "CAST (%s AS %s)",
                    getFormattedTypeName(fout, cast->castsource, zeroAsNone),
                   getFormattedTypeName(fout, cast->casttarget, zeroAsNone));

    if (binary_upgrade)
        binary_upgrade_extension_member(defqry, &cast->dobj, labelq->data);

    ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
                 labelq->data,
                 "pg_catalog", NULL, "",
                 false, "CAST", SECTION_PRE_DATA,
                 defqry->data, delqry->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Cast Comments */
    dumpComment(fout, labelq->data,
                NULL, "",
                cast->dobj.catId, 0, cast->dobj.dumpId);

    destroyPQExpBuffer(defqry);
    destroyPQExpBuffer(delqry);
    destroyPQExpBuffer(labelq);
}

static void dumpCollation ( Archive fout,
CollInfo convinfo 
) [static]

Definition at line 11164 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _collInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQueryForSingleRow(), fmtId(), _dumpableObject::name, NULL, CatalogId::oid, PQclear(), PQfnumber(), PQgetvalue(), _collInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PGresult   *res;
    int         i_collcollate;
    int         i_collctype;
    const char *collcollate;
    const char *collctype;

    /* Skip if not to be dumped */
    if (!collinfo->dobj.dump || dataOnly)
        return;

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, collinfo->dobj.namespace->dobj.name);

    /* Get conversion-specific details */
    appendPQExpBuffer(query, "SELECT "
                      "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_collcollate = PQfnumber(res, "collcollate");
    i_collctype = PQfnumber(res, "collctype");

    collcollate = PQgetvalue(res, 0, i_collcollate);
    collctype = PQgetvalue(res, 0, i_collctype);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP COLLATION %s",
                      fmtId(collinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s;\n",
                      fmtId(collinfo->dobj.name));

    appendPQExpBuffer(q, "CREATE COLLATION %s (lc_collate = ",
                      fmtId(collinfo->dobj.name));
    appendStringLiteralAH(q, collcollate, fout);
    appendPQExpBuffer(q, ", lc_ctype = ");
    appendStringLiteralAH(q, collctype, fout);
    appendPQExpBuffer(q, ");\n");

    appendPQExpBuffer(labelq, "COLLATION %s", fmtId(collinfo->dobj.name));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &collinfo->dobj, labelq->data);

    ArchiveEntry(fout, collinfo->dobj.catId, collinfo->dobj.dumpId,
                 collinfo->dobj.name,
                 collinfo->dobj.namespace->dobj.name,
                 NULL,
                 collinfo->rolname,
                 false, "COLLATION", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Collation Comments */
    dumpComment(fout, labelq->data,
                collinfo->dobj.namespace->dobj.name, collinfo->rolname,
                collinfo->dobj.catId, 0, collinfo->dobj.dumpId);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpComment ( Archive fout,
const char *  target,
const char *  namespace,
const char *  owner,
CatalogId  catalogId,
int  subid,
DumpId  dumpId 
) [static]

Definition at line 7322 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, CommentItem::descr, destroyPQExpBuffer(), findComments(), NULL, CommentItem::objsubid, CatalogId::oid, schemaOnly, SECTION_NONE, and CatalogId::tableoid.

Referenced by dumpAgg(), dumpBaseType(), dumpBlob(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpConversion(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpProcLang(), dumpRangeType(), dumpRule(), dumpSequence(), dumpTableConstraintComment(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), and dumpTSTemplate().

{
    CommentItem *comments;
    int         ncomments;

    /* Comments are schema not data ... except blob comments are data */
    if (strncmp(target, "LARGE OBJECT ", 13) != 0)
    {
        if (dataOnly)
            return;
    }
    else
    {
        if (schemaOnly)
            return;
    }

    /* Search for comments associated with catalogId, using table */
    ncomments = findComments(fout, catalogId.tableoid, catalogId.oid,
                             &comments);

    /* Is there one matching the subid? */
    while (ncomments > 0)
    {
        if (comments->objsubid == subid)
            break;
        comments++;
        ncomments--;
    }

    /* If a comment exists, build COMMENT ON statement */
    if (ncomments > 0)
    {
        PQExpBuffer query = createPQExpBuffer();

        appendPQExpBuffer(query, "COMMENT ON %s IS ", target);
        appendStringLiteralAH(query, comments->descr, fout);
        appendPQExpBuffer(query, ";\n");

        /*
         * 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(),
                     target, namespace, NULL, owner,
                     false, "COMMENT", SECTION_NONE,
                     query->data, "", NULL,
                     &(dumpId), 1,
                     NULL, NULL);

        destroyPQExpBuffer(query);
    }
}

static void dumpCompositeType ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 8793 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ArchiveEntry(), atooid, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _collInfo::dobj, dumpACL(), dumpComment(), dumpCompositeTypeColComments(), dumpSecLabel(), ExecuteSqlQuery(), findCollationByOid(), fmtId(), i, _dumpableObject::name, NULL, OidIsValid, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpType().

{
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer dropped = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    char       *qtypname;
    int         ntups;
    int         i_attname;
    int         i_atttypdefn;
    int         i_attlen;
    int         i_attalign;
    int         i_attisdropped;
    int         i_attcollation;
    int         i_typrelid;
    int         i;
    int         actual_atts;

    /* Set proper schema search path so type references list correctly */
    selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);

    /* Fetch type specific details */
    if (fout->remoteVersion >= 90100)
    {
        /*
         * attcollation is new in 9.1.  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.
         */
        appendPQExpBuffer(query, "SELECT a.attname, "
            "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, "
                          "ct.typrelid "
                          "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 = '%u'::pg_catalog.oid "
                          "ORDER BY a.attnum ",
                          tyinfo->dobj.catId.oid);
    }
    else
    {
        /*
         * We assume here that remoteVersion must be at least 70300.  Since
         * ALTER TYPE could not drop columns until 9.1, attisdropped should
         * always be false.
         */
        appendPQExpBuffer(query, "SELECT a.attname, "
            "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
                          "a.attlen, a.attalign, a.attisdropped, "
                          "0 AS attcollation, "
                          "ct.typrelid "
                     "FROM pg_catalog.pg_type ct, pg_catalog.pg_attribute a "
                          "WHERE ct.oid = '%u'::pg_catalog.oid "
                          "AND a.attrelid = ct.typrelid "
                          "ORDER BY a.attnum ",
                          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");
    i_typrelid = PQfnumber(res, "typrelid");

    if (binary_upgrade)
    {
        Oid         typrelid = atooid(PQgetvalue(res, 0, i_typrelid));

        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                                 tyinfo->dobj.catId.oid);
        binary_upgrade_set_pg_class_oids(fout, q, typrelid, false);
    }

    qtypname = pg_strdup(fmtId(tyinfo->dobj.name));

    appendPQExpBuffer(q, "CREATE TYPE %s AS (",
                      qtypname);

    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 && !binary_upgrade)
            continue;

        /* Format properly if not first attr */
        if (actual_atts++ > 0)
            appendPQExpBuffer(q, ",");
        appendPQExpBuffer(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)
                {
                    /* always schema-qualify, don't try to be smart */
                    appendPQExpBuffer(q, " COLLATE %s.",
                                      fmtId(coll->dobj.namespace->dobj.name));
                    appendPQExpBuffer(q, "%s",
                                      fmtId(coll->dobj.name));
                }
            }
        }
        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 */
            appendPQExpBuffer(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);
            appendPQExpBuffer(dropped, "\n  AND attrelid = ");
            appendStringLiteralAH(dropped, qtypname, fout);
            appendPQExpBuffer(dropped, "::pg_catalog.regclass;\n");

            appendPQExpBuffer(dropped, "ALTER TYPE %s ",
                              qtypname);
            appendPQExpBuffer(dropped, "DROP ATTRIBUTE %s;\n",
                              fmtId(attname));
        }
    }
    appendPQExpBuffer(q, "\n);\n");
    appendPQExpBufferStr(q, dropped->data);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP TYPE %s.",
                      fmtId(tyinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, "%s;\n",
                      qtypname);

    appendPQExpBuffer(labelq, "TYPE %s", qtypname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);

    ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                 tyinfo->dobj.name,
                 tyinfo->dobj.namespace->dobj.name,
                 NULL,
                 tyinfo->rolname, false,
                 "TYPE", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);


    /* Dump Type Comments and Security Labels */
    dumpComment(fout, labelq->data,
                tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                 tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);

    dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
            qtypname, NULL, tyinfo->dobj.name,
            tyinfo->dobj.namespace->dobj.name,
            tyinfo->rolname, tyinfo->typacl);

    PQclear(res);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(dropped);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);

    /* Dump any per-column comments */
    dumpCompositeTypeColComments(fout, tyinfo);
}

static void dumpCompositeTypeColComments ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 9014 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), atooid, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, CommentItem::descr, destroyPQExpBuffer(), ExecuteSqlQuery(), findComments(), fmtId(), i, NULL, CommentItem::objsubid, PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), resetPQExpBuffer(), and SECTION_NONE.

Referenced by dumpCompositeType().

{
    CommentItem *comments;
    int         ncomments;
    PGresult   *res;
    PQExpBuffer query;
    PQExpBuffer target;
    Oid         pgClassOid;
    int         i;
    int         ntups;
    int         i_attname;
    int         i_attnum;

    query = createPQExpBuffer();

    /* We assume here that remoteVersion must be at least 70300 */
    appendPQExpBuffer(query,
                      "SELECT c.tableoid, a.attname, a.attnum "
                      "FROM pg_catalog.pg_class c, pg_catalog.pg_attribute a "
                      "WHERE c.oid = '%u' AND c.oid = a.attrelid "
                      "  AND NOT a.attisdropped "
                      "ORDER BY a.attnum ",
                      tyinfo->typrelid);

    /* Fetch column attnames */
    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    if (ntups < 1)
    {
        PQclear(res);
        destroyPQExpBuffer(query);
        return;
    }

    pgClassOid = atooid(PQgetvalue(res, 0, PQfnumber(res, "tableoid")));

    /* Search for comments associated with type's pg_class OID */
    ncomments = findComments(fout,
                             pgClassOid,
                             tyinfo->typrelid,
                             &comments);

    /* If no comments exist, we're done */
    if (ncomments <= 0)
    {
        PQclear(res);
        destroyPQExpBuffer(query);
        return;
    }

    /* Build COMMENT ON statements */
    target = createPQExpBuffer();

    i_attnum = PQfnumber(res, "attnum");
    i_attname = PQfnumber(res, "attname");
    while (ncomments > 0)
    {
        const char *attname;

        attname = NULL;
        for (i = 0; i < ntups; i++)
        {
            if (atoi(PQgetvalue(res, i, i_attnum)) == comments->objsubid)
            {
                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));
            appendPQExpBuffer(target, "%s",
                              fmtId(attname));

            resetPQExpBuffer(query);
            appendPQExpBuffer(query, "COMMENT ON %s IS ", target->data);
            appendStringLiteralAH(query, descr, fout);
            appendPQExpBuffer(query, ";\n");

            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         target->data,
                         tyinfo->dobj.namespace->dobj.name,
                         NULL, tyinfo->rolname,
                         false, "COMMENT", SECTION_NONE,
                         query->data, "", NULL,
                         &(tyinfo->dobj.dumpId), 1,
                         NULL, NULL);
        }

        comments++;
        ncomments--;
    }

    PQclear(res);
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(target);
}

static void dumpConstraint ( Archive fout,
ConstraintInfo coninfo 
) [static]

Definition at line 13542 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_set_pg_class_oids(), _dumpableObject::catId, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::conindex, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _indxInfo::dobj, _constraintInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, dumpTableConstraintComment(), exit_horribly(), findObjectByDumpId(), fmtId(), getAttrName(), _indxInfo::indisclustered, _indxInfo::indkeys, _indxInfo::indnkeys, InvalidAttrNumber, _dumpableObject::name, NULL, CatalogId::oid, _indxInfo::options, _tableInfo::rolname, SECTION_POST_DATA, _constraintInfo::separate, and _indxInfo::tablespace.

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = coninfo->contable;
    PQExpBuffer q;
    PQExpBuffer delq;

    /* Skip if not to be dumped */
    if (!coninfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();

    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)
            exit_horribly(NULL, "missing index for constraint \"%s\"\n",
                          coninfo->dobj.name);

        if (binary_upgrade)
            binary_upgrade_set_pg_class_oids(fout, q,
                                             indxinfo->dobj.catId.oid, true);

        appendPQExpBuffer(q, "ALTER TABLE ONLY %s\n",
                          fmtId(tbinfo->dobj.name));
        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
        {
            appendPQExpBuffer(q, "%s (",
                         coninfo->contype == 'p' ? "PRIMARY KEY" : "UNIQUE");
            for (k = 0; k < indxinfo->indnkeys; 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));
            }

            appendPQExpBuffer(q, ")");

            if (indxinfo->options && strlen(indxinfo->options) > 0)
                appendPQExpBuffer(q, " WITH (%s)", indxinfo->options);

            if (coninfo->condeferrable)
            {
                appendPQExpBuffer(q, " DEFERRABLE");
                if (coninfo->condeferred)
                    appendPQExpBuffer(q, " INITIALLY DEFERRED");
            }

            appendPQExpBuffer(q, ";\n");
        }

        /* If the index is clustered, we need to record that. */
        if (indxinfo->indisclustered)
        {
            appendPQExpBuffer(q, "\nALTER TABLE %s CLUSTER",
                              fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(q, " ON %s;\n",
                              fmtId(indxinfo->dobj.name));
        }

        /*
         * DROP must be fully qualified in case same name appears in
         * pg_catalog
         */
        appendPQExpBuffer(delq, "ALTER TABLE ONLY %s.",
                          fmtId(tbinfo->dobj.namespace->dobj.name));
        appendPQExpBuffer(delq, "%s ",
                          fmtId(tbinfo->dobj.name));
        appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                          fmtId(coninfo->dobj.name));

        ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                     coninfo->dobj.name,
                     tbinfo->dobj.namespace->dobj.name,
                     indxinfo->tablespace,
                     tbinfo->rolname, false,
                     "CONSTRAINT", SECTION_POST_DATA,
                     q->data, delq->data, NULL,
                     NULL, 0,
                     NULL, NULL);
    }
    else if (coninfo->contype == 'f')
    {
        /*
         * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
         * current table data is not processed
         */
        appendPQExpBuffer(q, "ALTER TABLE ONLY %s\n",
                          fmtId(tbinfo->dobj.name));
        appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
                          fmtId(coninfo->dobj.name),
                          coninfo->condef);

        /*
         * DROP must be fully qualified in case same name appears in
         * pg_catalog
         */
        appendPQExpBuffer(delq, "ALTER TABLE ONLY %s.",
                          fmtId(tbinfo->dobj.namespace->dobj.name));
        appendPQExpBuffer(delq, "%s ",
                          fmtId(tbinfo->dobj.name));
        appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                          fmtId(coninfo->dobj.name));

        ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                     coninfo->dobj.name,
                     tbinfo->dobj.namespace->dobj.name,
                     NULL,
                     tbinfo->rolname, false,
                     "FK CONSTRAINT", SECTION_POST_DATA,
                     q->data, delq->data, NULL,
                     NULL, 0,
                     NULL, NULL);
    }
    else if (coninfo->contype == 'c' && tbinfo)
    {
        /* CHECK constraint on a table */

        /* Ignore if not to be dumped separately */
        if (coninfo->separate)
        {
            /* not ONLY since we want it to propagate to children */
            appendPQExpBuffer(q, "ALTER TABLE %s\n",
                              fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
                              fmtId(coninfo->dobj.name),
                              coninfo->condef);

            /*
             * DROP must be fully qualified in case same name appears in
             * pg_catalog
             */
            appendPQExpBuffer(delq, "ALTER TABLE %s.",
                              fmtId(tbinfo->dobj.namespace->dobj.name));
            appendPQExpBuffer(delq, "%s ",
                              fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                              fmtId(coninfo->dobj.name));

            ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                         coninfo->dobj.name,
                         tbinfo->dobj.namespace->dobj.name,
                         NULL,
                         tbinfo->rolname, false,
                         "CHECK CONSTRAINT", SECTION_POST_DATA,
                         q->data, delq->data, NULL,
                         NULL, 0,
                         NULL, NULL);
        }
    }
    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",
                              fmtId(tyinfo->dobj.name));
            appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
                              fmtId(coninfo->dobj.name),
                              coninfo->condef);

            /*
             * DROP must be fully qualified in case same name appears in
             * pg_catalog
             */
            appendPQExpBuffer(delq, "ALTER DOMAIN %s.",
                              fmtId(tyinfo->dobj.namespace->dobj.name));
            appendPQExpBuffer(delq, "%s ",
                              fmtId(tyinfo->dobj.name));
            appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
                              fmtId(coninfo->dobj.name));

            ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
                         coninfo->dobj.name,
                         tyinfo->dobj.namespace->dobj.name,
                         NULL,
                         tyinfo->rolname, false,
                         "CHECK CONSTRAINT", SECTION_POST_DATA,
                         q->data, delq->data, NULL,
                         NULL, 0,
                         NULL, NULL);
        }
    }
    else
    {
        exit_horribly(NULL, "unrecognized constraint type: %c\n",
                      coninfo->contype);
    }

    /* Dump Constraint Comments --- only works for table constraints */
    if (tbinfo && coninfo->separate)
        dumpTableConstraintComment(fout, coninfo);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
}

static void dumpConversion ( Archive fout,
ConvInfo convinfo 
) [static]

Definition at line 11252 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _convInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQueryForSingleRow(), fmtId(), _dumpableObject::name, NULL, CatalogId::oid, PQclear(), PQfnumber(), PQgetvalue(), _convInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    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;

    /* Skip if not to be dumped */
    if (!convinfo->dobj.dump || dataOnly)
        return;

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, convinfo->dobj.namespace->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');

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP CONVERSION %s",
                      fmtId(convinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s;\n",
                      fmtId(convinfo->dobj.name));

    appendPQExpBuffer(q, "CREATE %sCONVERSION %s FOR ",
                      (condefault) ? "DEFAULT " : "",
                      fmtId(convinfo->dobj.name));
    appendStringLiteralAH(q, conforencoding, fout);
    appendPQExpBuffer(q, " TO ");
    appendStringLiteralAH(q, contoencoding, fout);
    /* regproc is automatically quoted in 7.3 and above */
    appendPQExpBuffer(q, " FROM %s;\n", conproc);

    appendPQExpBuffer(labelq, "CONVERSION %s", fmtId(convinfo->dobj.name));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &convinfo->dobj, labelq->data);

    ArchiveEntry(fout, convinfo->dobj.catId, convinfo->dobj.dumpId,
                 convinfo->dobj.name,
                 convinfo->dobj.namespace->dobj.name,
                 NULL,
                 convinfo->rolname,
                 false, "CONVERSION", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Conversion Comments */
    dumpComment(fout, labelq->data,
                convinfo->dobj.namespace->dobj.name, convinfo->rolname,
                convinfo->dobj.catId, 0, convinfo->dobj.dumpId);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpDatabase ( Archive AH  )  [static]

Definition at line 2107 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), atooid, binary_upgrade, buildShSecLabelQuery(), conn, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), dumpComment(), emitShSecLabels(), encoding, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fmtId(), g_verbose, GetConnection(), LargeObjectMetadataRelationId, LargeObjectRelationId, no_security_labels, NULL, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQdb(), PQfnumber(), PQgetvalue(), Archive::remoteVersion, resetPQExpBuffer(), SECTION_NONE, SECTION_PRE_DATA, selectSourceSchema(), CatalogId::tableoid, tablespace, username_subquery, and write_msg().

Referenced by main().

{
    PQExpBuffer dbQry = createPQExpBuffer();
    PQExpBuffer delQry = createPQExpBuffer();
    PQExpBuffer creaQry = createPQExpBuffer();
    PGconn     *conn = GetConnection(fout);
    PGresult   *res;
    int         i_tableoid,
                i_oid,
                i_dba,
                i_encoding,
                i_collate,
                i_ctype,
                i_frozenxid,
                i_tablespace;
    CatalogId   dbCatId;
    DumpId      dbDumpId;
    const char *datname,
               *dba,
               *encoding,
               *collate,
               *ctype,
               *tablespace;
    uint32      frozenxid;

    datname = PQdb(conn);

    if (g_verbose)
        write_msg(NULL, "saving database definition\n");

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /* Get the database owner and parameters from pg_database */
    if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(dbQry, "SELECT tableoid, oid, "
                          "(%s datdba) AS dba, "
                          "pg_encoding_to_char(encoding) AS encoding, "
                          "datcollate, datctype, datfrozenxid, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
                      "shobj_description(oid, 'pg_database') AS description "

                          "FROM pg_database "
                          "WHERE datname = ",
                          username_subquery);
        appendStringLiteralAH(dbQry, datname, fout);
    }
    else if (fout->remoteVersion >= 80200)
    {
        appendPQExpBuffer(dbQry, "SELECT tableoid, oid, "
                          "(%s datdba) AS dba, "
                          "pg_encoding_to_char(encoding) AS encoding, "
                       "NULL AS datcollate, NULL AS datctype, datfrozenxid, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
                      "shobj_description(oid, 'pg_database') AS description "

                          "FROM pg_database "
                          "WHERE datname = ",
                          username_subquery);
        appendStringLiteralAH(dbQry, datname, fout);
    }
    else if (fout->remoteVersion >= 80000)
    {
        appendPQExpBuffer(dbQry, "SELECT tableoid, oid, "
                          "(%s datdba) AS dba, "
                          "pg_encoding_to_char(encoding) AS encoding, "
                       "NULL AS datcollate, NULL AS datctype, datfrozenxid, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace "
                          "FROM pg_database "
                          "WHERE datname = ",
                          username_subquery);
        appendStringLiteralAH(dbQry, datname, fout);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(dbQry, "SELECT tableoid, oid, "
                          "(%s datdba) AS dba, "
                          "pg_encoding_to_char(encoding) AS encoding, "
                          "NULL AS datcollate, NULL AS datctype, "
                          "0 AS datfrozenxid, "
                          "NULL AS tablespace "
                          "FROM pg_database "
                          "WHERE datname = ",
                          username_subquery);
        appendStringLiteralAH(dbQry, datname, fout);
    }
    else
    {
        appendPQExpBuffer(dbQry, "SELECT "
                          "(SELECT oid FROM pg_class WHERE relname = 'pg_database') AS tableoid, "
                          "oid, "
                          "(%s datdba) AS dba, "
                          "pg_encoding_to_char(encoding) AS encoding, "
                          "NULL AS datcollate, NULL AS datctype, "
                          "0 AS datfrozenxid, "
                          "NULL AS tablespace "
                          "FROM pg_database "
                          "WHERE datname = ",
                          username_subquery);
        appendStringLiteralAH(dbQry, datname, fout);
    }

    res = ExecuteSqlQueryForSingleRow(fout, dbQry->data);

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_dba = PQfnumber(res, "dba");
    i_encoding = PQfnumber(res, "encoding");
    i_collate = PQfnumber(res, "datcollate");
    i_ctype = PQfnumber(res, "datctype");
    i_frozenxid = PQfnumber(res, "datfrozenxid");
    i_tablespace = PQfnumber(res, "tablespace");

    dbCatId.tableoid = atooid(PQgetvalue(res, 0, i_tableoid));
    dbCatId.oid = atooid(PQgetvalue(res, 0, i_oid));
    dba = PQgetvalue(res, 0, i_dba);
    encoding = PQgetvalue(res, 0, i_encoding);
    collate = PQgetvalue(res, 0, i_collate);
    ctype = PQgetvalue(res, 0, i_ctype);
    frozenxid = atooid(PQgetvalue(res, 0, i_frozenxid));
    tablespace = PQgetvalue(res, 0, i_tablespace);

    appendPQExpBuffer(creaQry, "CREATE DATABASE %s WITH TEMPLATE = template0",
                      fmtId(datname));
    if (strlen(encoding) > 0)
    {
        appendPQExpBuffer(creaQry, " ENCODING = ");
        appendStringLiteralAH(creaQry, encoding, fout);
    }
    if (strlen(collate) > 0)
    {
        appendPQExpBuffer(creaQry, " LC_COLLATE = ");
        appendStringLiteralAH(creaQry, collate, fout);
    }
    if (strlen(ctype) > 0)
    {
        appendPQExpBuffer(creaQry, " LC_CTYPE = ");
        appendStringLiteralAH(creaQry, ctype, fout);
    }
    if (strlen(tablespace) > 0 && strcmp(tablespace, "pg_default") != 0)
        appendPQExpBuffer(creaQry, " TABLESPACE = %s",
                          fmtId(tablespace));
    appendPQExpBuffer(creaQry, ";\n");

    if (binary_upgrade)
    {
        appendPQExpBuffer(creaQry, "\n-- For binary upgrade, set datfrozenxid.\n");
        appendPQExpBuffer(creaQry, "UPDATE pg_catalog.pg_database\n"
                          "SET datfrozenxid = '%u'\n"
                          "WHERE    datname = ",
                          frozenxid);
        appendStringLiteralAH(creaQry, datname, fout);
        appendPQExpBuffer(creaQry, ";\n");

    }

    appendPQExpBuffer(delQry, "DROP DATABASE %s;\n",
                      fmtId(datname));

    dbDumpId = createDumpId();

    ArchiveEntry(fout,
                 dbCatId,       /* catalog ID */
                 dbDumpId,      /* dump ID */
                 datname,       /* Name */
                 NULL,          /* Namespace */
                 NULL,          /* Tablespace */
                 dba,           /* Owner */
                 false,         /* with oids */
                 "DATABASE",    /* Desc */
                 SECTION_PRE_DATA,      /* Section */
                 creaQry->data, /* Create */
                 delQry->data,  /* Del */
                 NULL,          /* Copy */
                 NULL,          /* Deps */
                 0,             /* # Deps */
                 NULL,          /* Dumper */
                 NULL);         /* Dumper Arg */

    /*
     * pg_largeobject and pg_largeobject_metadata come from the old system
     * intact, so set their relfrozenxids.
     */
    if (binary_upgrade)
    {
        PGresult   *lo_res;
        PQExpBuffer loFrozenQry = createPQExpBuffer();
        PQExpBuffer loOutQry = createPQExpBuffer();
        int         i_relfrozenxid;

        /*
         * pg_largeobject
         */
        appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid\n"
                          "FROM pg_catalog.pg_class\n"
                          "WHERE oid = %u;\n",
                          LargeObjectRelationId);

        lo_res = ExecuteSqlQueryForSingleRow(fout, loFrozenQry->data);

        i_relfrozenxid = PQfnumber(lo_res, "relfrozenxid");

        appendPQExpBuffer(loOutQry, "\n-- For binary upgrade, set pg_largeobject.relfrozenxid\n");
        appendPQExpBuffer(loOutQry, "UPDATE pg_catalog.pg_class\n"
                          "SET relfrozenxid = '%u'\n"
                          "WHERE oid = %u;\n",
                          atoi(PQgetvalue(lo_res, 0, i_relfrozenxid)),
                          LargeObjectRelationId);
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     "pg_largeobject", NULL, NULL, "",
                     false, "pg_largeobject", SECTION_PRE_DATA,
                     loOutQry->data, "", NULL,
                     NULL, 0,
                     NULL, NULL);

        PQclear(lo_res);

        /*
         * pg_largeobject_metadata
         */
        if (fout->remoteVersion >= 90000)
        {
            resetPQExpBuffer(loFrozenQry);
            resetPQExpBuffer(loOutQry);

            appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid\n"
                              "FROM pg_catalog.pg_class\n"
                              "WHERE oid = %u;\n",
                              LargeObjectMetadataRelationId);

            lo_res = ExecuteSqlQueryForSingleRow(fout, loFrozenQry->data);

            i_relfrozenxid = PQfnumber(lo_res, "relfrozenxid");

            appendPQExpBuffer(loOutQry, "\n-- For binary upgrade, set pg_largeobject_metadata.relfrozenxid\n");
            appendPQExpBuffer(loOutQry, "UPDATE pg_catalog.pg_class\n"
                              "SET relfrozenxid = '%u'\n"
                              "WHERE oid = %u;\n",
                              atoi(PQgetvalue(lo_res, 0, i_relfrozenxid)),
                              LargeObjectMetadataRelationId);
            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         "pg_largeobject_metadata", NULL, NULL, "",
                         false, "pg_largeobject_metadata", SECTION_PRE_DATA,
                         loOutQry->data, "", NULL,
                         NULL, 0,
                         NULL, NULL);

            PQclear(lo_res);
        }

        destroyPQExpBuffer(loFrozenQry);
        destroyPQExpBuffer(loOutQry);
    }

    /* Dump DB comment if any */
    if (fout->remoteVersion >= 80200)
    {
        /*
         * 8.2 keeps comments on shared objects in a shared table, so we
         * cannot use the dumpComment used for other database objects.
         */
        char       *comment = PQgetvalue(res, 0, PQfnumber(res, "description"));

        if (comment && strlen(comment))
        {
            resetPQExpBuffer(dbQry);

            /*
             * Generates warning when loaded into a differently-named
             * database.
             */
            appendPQExpBuffer(dbQry, "COMMENT ON DATABASE %s IS ", fmtId(datname));
            appendStringLiteralAH(dbQry, comment, fout);
            appendPQExpBuffer(dbQry, ";\n");

            ArchiveEntry(fout, dbCatId, createDumpId(), datname, NULL, NULL,
                         dba, false, "COMMENT", SECTION_NONE,
                         dbQry->data, "", NULL,
                         &dbDumpId, 1, NULL, NULL);
        }
    }
    else
    {
        resetPQExpBuffer(dbQry);
        appendPQExpBuffer(dbQry, "DATABASE %s", fmtId(datname));
        dumpComment(fout, dbQry->data, NULL, "",
                    dbCatId, 0, dbDumpId);
    }

    PQclear(res);

    /* Dump shared security label. */
    if (!no_security_labels && fout->remoteVersion >= 90200)
    {
        PQExpBuffer seclabelQry = createPQExpBuffer();

        buildShSecLabelQuery(conn, "pg_database", dbCatId.oid, seclabelQry);
        res = ExecuteSqlQuery(fout, seclabelQry->data, PGRES_TUPLES_OK);
        resetPQExpBuffer(seclabelQry);
        emitShSecLabels(conn, res, seclabelQry, "DATABASE", datname);
        if (strlen(seclabelQry->data))
            ArchiveEntry(fout, dbCatId, createDumpId(), datname, NULL, NULL,
                         dba, false, "SECURITY LABEL", SECTION_NONE,
                         seclabelQry->data, "", NULL,
                         &dbDumpId, 1, NULL, NULL);
        destroyPQExpBuffer(seclabelQry);
    }

    destroyPQExpBuffer(dbQry);
    destroyPQExpBuffer(delQry);
    destroyPQExpBuffer(creaQry);
}

static void dumpDefaultACL ( Archive fout,
DefaultACLInfo daclinfo 
) [static]

Definition at line 12244 of file pg_dump.c.

References aclsSkip, appendPQExpBuffer(), ArchiveEntry(), buildDefaultACLCommands(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, _defaultACLInfo::defaclacl, DEFACLOBJ_FUNCTION, DEFACLOBJ_RELATION, DEFACLOBJ_SEQUENCE, DEFACLOBJ_TYPE, _defaultACLInfo::defaclobjtype, _defaultACLInfo::defaclrole, destroyPQExpBuffer(), _defaultACLInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, exit_horribly(), _dumpableObject::name, NULL, Archive::remoteVersion, and SECTION_POST_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer tag;
    const char *type;

    /* Skip if not to be dumped */
    if (!daclinfo->dobj.dump || dataOnly || 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;
        default:
            /* shouldn't get here */
            exit_horribly(NULL,
                      "unrecognized object type in default privileges: %d\n",
                          (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->defaclacl,
                                 daclinfo->defaclrole,
                                 fout->remoteVersion,
                                 q))
        exit_horribly(NULL, "could not parse default ACL list (%s)\n",
                      daclinfo->defaclacl);

    ArchiveEntry(fout, daclinfo->dobj.catId, daclinfo->dobj.dumpId,
                 tag->data,
       daclinfo->dobj.namespace ? daclinfo->dobj.namespace->dobj.name : NULL,
                 NULL,
                 daclinfo->defaclrole,
                 false, "DEFAULT ACL", SECTION_POST_DATA,
                 q->data, "", NULL,
                 NULL, 0,
                 NULL, NULL);

    destroyPQExpBuffer(tag);
    destroyPQExpBuffer(q);
}

static void dumpDomain ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 8630 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ArchiveEntry(), atooid, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), _constraintInfo::condef, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _collInfo::dobj, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), findCollationByOid(), fmtId(), i, _dumpableObject::name, NULL, OidIsValid, pg_strdup(), PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), Archive::remoteVersion, SECTION_PRE_DATA, selectSourceSchema(), and _constraintInfo::separate.

Referenced by dumpType().

{
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    int         i;
    char       *qtypname;
    char       *typnotnull;
    char       *typdefn;
    char       *typdefault;
    Oid         typcollation;
    bool        typdefault_is_literal = false;

    /* Set proper schema search path so type references list correctly */
    selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);

    /* Fetch domain specific details */
    if (fout->remoteVersion >= 90100)
    {
        /* typcollation is new in 9.1 */
        appendPQExpBuffer(query, "SELECT t.typnotnull, "
            "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
                          "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
                          "t.typdefault, "
                          "CASE WHEN t.typcollation <> u.typcollation "
                          "THEN t.typcollation ELSE 0 END AS typcollation "
                          "FROM pg_catalog.pg_type t "
                 "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
                          "WHERE t.oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }
    else
    {
        /* We assume here that remoteVersion must be at least 70300 */
        appendPQExpBuffer(query, "SELECT typnotnull, "
                "pg_catalog.format_type(typbasetype, typtypmod) AS typdefn, "
                          "pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
                          "typdefault, 0 AS typcollation "
                          "FROM pg_catalog.pg_type "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          tyinfo->dobj.catId.oid);
    }

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    typnotnull = PQgetvalue(res, 0, PQfnumber(res, "typnotnull"));
    typdefn = PQgetvalue(res, 0, PQfnumber(res, "typdefn"));
    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;
    typcollation = atooid(PQgetvalue(res, 0, PQfnumber(res, "typcollation")));

    if (binary_upgrade)
        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                                 tyinfo->dobj.catId.oid);

    qtypname = pg_strdup(fmtId(tyinfo->dobj.name));

    appendPQExpBuffer(q,
                      "CREATE DOMAIN %s AS %s",
                      qtypname,
                      typdefn);

    /* Print collation only if different from base type's collation */
    if (OidIsValid(typcollation))
    {
        CollInfo   *coll;

        coll = findCollationByOid(typcollation);
        if (coll)
        {
            /* always schema-qualify, don't try to be smart */
            appendPQExpBuffer(q, " COLLATE %s.",
                              fmtId(coll->dobj.namespace->dobj.name));
            appendPQExpBuffer(q, "%s",
                              fmtId(coll->dobj.name));
        }
    }

    if (typnotnull[0] == 't')
        appendPQExpBuffer(q, " NOT NULL");

    if (typdefault != NULL)
    {
        appendPQExpBuffer(q, " DEFAULT ");
        if (typdefault_is_literal)
            appendStringLiteralAH(q, typdefault, fout);
        else
            appendPQExpBufferStr(q, typdefault);
    }

    PQclear(res);

    /*
     * Add any CHECK constraints for the domain
     */
    for (i = 0; i < tyinfo->nDomChecks; i++)
    {
        ConstraintInfo *domcheck = &(tyinfo->domChecks[i]);

        if (!domcheck->separate)
            appendPQExpBuffer(q, "\n\tCONSTRAINT %s %s",
                              fmtId(domcheck->dobj.name), domcheck->condef);
    }

    appendPQExpBuffer(q, ";\n");

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP DOMAIN %s.",
                      fmtId(tyinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, "%s;\n",
                      qtypname);

    appendPQExpBuffer(labelq, "DOMAIN %s", qtypname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);

    ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                 tyinfo->dobj.name,
                 tyinfo->dobj.namespace->dobj.name,
                 NULL,
                 tyinfo->rolname, false,
                 "DOMAIN", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Domain Comments and Security Labels */
    dumpComment(fout, labelq->data,
                tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                 tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);

    dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
            qtypname, NULL, tyinfo->dobj.name,
            tyinfo->dobj.namespace->dobj.name,
            tyinfo->rolname, tyinfo->typacl);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);
}

static void dumpDumpableObject ( Archive fout,
DumpableObject dobj 
) [static]

Definition at line 7641 of file pg_dump.c.

References ArchiveEntry(), DO_AGG, DO_ATTRDEF, DO_BLOB, DO_BLOB_DATA, 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_NAMESPACE, DO_OPCLASS, DO_OPERATOR, DO_OPFAMILY, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, DO_PROCLANG, DO_REFRESH_MATVIEW, DO_RULE, DO_SHELL_TYPE, DO_TABLE, DO_TABLE_DATA, DO_TRIGGER, DO_TSCONFIG, DO_TSDICT, DO_TSPARSER, DO_TSTEMPLATE, DO_TYPE, dumpAgg(), dumpAttrDef(), dumpBlob(), dumpBlobs(), dumpCast(), dumpCollation(), dumpConstraint(), dumpConversion(), dumpDefaultACL(), dumpEventTrigger(), dumpExtension(), dumpForeignDataWrapper(), dumpForeignServer(), dumpFunc(), dumpIndex(), dumpNamespace(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpProcLang(), dumpRule(), dumpSequenceData(), dumpShellType(), dumpTable(), dumpTableData(), dumpTrigger(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpType(), NULL, _dumpableObject::objType, refreshMatViewData(), RELKIND_SEQUENCE, and SECTION_DATA.

Referenced by main().

{
    switch (dobj->objType)
    {
        case DO_NAMESPACE:
            dumpNamespace(fout, (NamespaceInfo *) dobj);
            break;
        case DO_EXTENSION:
            dumpExtension(fout, (ExtensionInfo *) dobj);
            break;
        case DO_TYPE:
            dumpType(fout, (TypeInfo *) dobj);
            break;
        case DO_SHELL_TYPE:
            dumpShellType(fout, (ShellTypeInfo *) dobj);
            break;
        case DO_FUNC:
            dumpFunc(fout, (FuncInfo *) dobj);
            break;
        case DO_AGG:
            dumpAgg(fout, (AggInfo *) dobj);
            break;
        case DO_OPERATOR:
            dumpOpr(fout, (OprInfo *) dobj);
            break;
        case DO_OPCLASS:
            dumpOpclass(fout, (OpclassInfo *) dobj);
            break;
        case DO_OPFAMILY:
            dumpOpfamily(fout, (OpfamilyInfo *) dobj);
            break;
        case DO_COLLATION:
            dumpCollation(fout, (CollInfo *) dobj);
            break;
        case DO_CONVERSION:
            dumpConversion(fout, (ConvInfo *) dobj);
            break;
        case DO_TABLE:
            dumpTable(fout, (TableInfo *) dobj);
            break;
        case DO_ATTRDEF:
            dumpAttrDef(fout, (AttrDefInfo *) dobj);
            break;
        case DO_INDEX:
            dumpIndex(fout, (IndxInfo *) dobj);
            break;
        case DO_REFRESH_MATVIEW:
            refreshMatViewData(fout, (TableDataInfo *) dobj);
            break;
        case DO_RULE:
            dumpRule(fout, (RuleInfo *) dobj);
            break;
        case DO_TRIGGER:
            dumpTrigger(fout, (TriggerInfo *) dobj);
            break;
        case DO_EVENT_TRIGGER:
            dumpEventTrigger(fout, (EventTriggerInfo *) dobj);
            break;
        case DO_CONSTRAINT:
            dumpConstraint(fout, (ConstraintInfo *) dobj);
            break;
        case DO_FK_CONSTRAINT:
            dumpConstraint(fout, (ConstraintInfo *) dobj);
            break;
        case DO_PROCLANG:
            dumpProcLang(fout, (ProcLangInfo *) dobj);
            break;
        case DO_CAST:
            dumpCast(fout, (CastInfo *) dobj);
            break;
        case DO_TABLE_DATA:
            if (((TableDataInfo *) dobj)->tdtable->relkind == RELKIND_SEQUENCE)
                dumpSequenceData(fout, (TableDataInfo *) dobj);
            else
                dumpTableData(fout, (TableDataInfo *) dobj);
            break;
        case DO_DUMMY_TYPE:
            /* table rowtypes and array types are never dumped separately */
            break;
        case DO_TSPARSER:
            dumpTSParser(fout, (TSParserInfo *) dobj);
            break;
        case DO_TSDICT:
            dumpTSDictionary(fout, (TSDictInfo *) dobj);
            break;
        case DO_TSTEMPLATE:
            dumpTSTemplate(fout, (TSTemplateInfo *) dobj);
            break;
        case DO_TSCONFIG:
            dumpTSConfig(fout, (TSConfigInfo *) dobj);
            break;
        case DO_FDW:
            dumpForeignDataWrapper(fout, (FdwInfo *) dobj);
            break;
        case DO_FOREIGN_SERVER:
            dumpForeignServer(fout, (ForeignServerInfo *) dobj);
            break;
        case DO_DEFAULT_ACL:
            dumpDefaultACL(fout, (DefaultACLInfo *) dobj);
            break;
        case DO_BLOB:
            dumpBlob(fout, (BlobInfo *) dobj);
            break;
        case DO_BLOB_DATA:
            ArchiveEntry(fout, dobj->catId, dobj->dumpId,
                         dobj->name, NULL, NULL, "",
                         false, "BLOBS", SECTION_DATA,
                         "", "", NULL,
                         NULL, 0,
                         dumpBlobs, NULL);
            break;
        case DO_PRE_DATA_BOUNDARY:
        case DO_POST_DATA_BOUNDARY:
            /* never dumped, nothing to do */
            break;
    }
}

static void dumpEncoding ( Archive AH  )  [static]

Definition at line 2426 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), Archive::encoding, g_verbose, NULL, pg_encoding_to_char(), SECTION_PRE_DATA, and write_msg().

Referenced by main().

{
    const char *encname = pg_encoding_to_char(AH->encoding);
    PQExpBuffer qry = createPQExpBuffer();

    if (g_verbose)
        write_msg(NULL, "saving encoding = %s\n", encname);

    appendPQExpBuffer(qry, "SET client_encoding = ");
    appendStringLiteralAH(qry, encname, AH);
    appendPQExpBuffer(qry, ";\n");

    ArchiveEntry(AH, nilCatalogId, createDumpId(),
                 "ENCODING", NULL, NULL, "",
                 false, "ENCODING", SECTION_PRE_DATA,
                 qry->data, "", NULL,
                 NULL, 0,
                 NULL, NULL);

    destroyPQExpBuffer(qry);
}

static void dumpEnumType ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 7978 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), atooid, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQuery(), fmtId(), i, label, NULL, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpType().

{
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    int         num,
                i;
    Oid         enum_oid;
    char       *qtypname;
    char       *label;

    /* Set proper schema search path */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 90100)
        appendPQExpBuffer(query, "SELECT oid, enumlabel "
                          "FROM pg_catalog.pg_enum "
                          "WHERE enumtypid = '%u'"
                          "ORDER BY enumsortorder",
                          tyinfo->dobj.catId.oid);
    else
        appendPQExpBuffer(query, "SELECT oid, enumlabel "
                          "FROM pg_catalog.pg_enum "
                          "WHERE enumtypid = '%u'"
                          "ORDER BY oid",
                          tyinfo->dobj.catId.oid);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    num = PQntuples(res);

    qtypname = pg_strdup(fmtId(tyinfo->dobj.name));

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog.
     * CASCADE shouldn't be required here as for normal types since the I/O
     * functions are generic and do not get dropped.
     */
    appendPQExpBuffer(delq, "DROP TYPE %s.",
                      fmtId(tyinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, "%s;\n",
                      qtypname);

    if (binary_upgrade)
        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                                 tyinfo->dobj.catId.oid);

    appendPQExpBuffer(q, "CREATE TYPE %s AS ENUM (",
                      qtypname);

    if (!binary_upgrade)
    {
        /* Labels with server-assigned oids */
        for (i = 0; i < num; i++)
        {
            label = PQgetvalue(res, i, PQfnumber(res, "enumlabel"));
            if (i > 0)
                appendPQExpBuffer(q, ",");
            appendPQExpBuffer(q, "\n    ");
            appendStringLiteralAH(q, label, fout);
        }
    }

    appendPQExpBuffer(q, "\n);\n");

    if (binary_upgrade)
    {
        /* Labels with dump-assigned (preserved) oids */
        for (i = 0; i < num; i++)
        {
            enum_oid = atooid(PQgetvalue(res, i, PQfnumber(res, "oid")));
            label = PQgetvalue(res, i, PQfnumber(res, "enumlabel"));

            if (i == 0)
                appendPQExpBuffer(q, "\n-- For binary upgrade, must preserve pg_enum oids\n");
            appendPQExpBuffer(q,
                              "SELECT binary_upgrade.set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
                              enum_oid);
            appendPQExpBuffer(q, "ALTER TYPE %s.",
                              fmtId(tyinfo->dobj.namespace->dobj.name));
            appendPQExpBuffer(q, "%s ADD VALUE ",
                              qtypname);
            appendStringLiteralAH(q, label, fout);
            appendPQExpBuffer(q, ";\n\n");
        }
    }

    appendPQExpBuffer(labelq, "TYPE %s", qtypname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);

    ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                 tyinfo->dobj.name,
                 tyinfo->dobj.namespace->dobj.name,
                 NULL,
                 tyinfo->rolname, false,
                 "TYPE", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Type Comments and Security Labels */
    dumpComment(fout, labelq->data,
                tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                 tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);

    dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
            qtypname, NULL, tyinfo->dobj.name,
            tyinfo->dobj.namespace->dobj.name,
            tyinfo->rolname, tyinfo->typacl);

    PQclear(res);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);
}

static void dumpEventTrigger ( Archive fout,
EventTriggerInfo evtinfo 
) [static]

Definition at line 14300 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), ArchiveEntry(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _evttriggerInfo::dobj, dumpComment(), _dumpableObject::dumpId, _evttriggerInfo::evtenabled, _evttriggerInfo::evtevent, _evttriggerInfo::evtfname, _evttriggerInfo::evtowner, _evttriggerInfo::evttags, fmtId(), _dumpableObject::name, NULL, and SECTION_POST_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer labelq;

    query = createPQExpBuffer();
    labelq = createPQExpBuffer();

    appendPQExpBuffer(query, "CREATE EVENT TRIGGER ");
    appendPQExpBufferStr(query, fmtId(evtinfo->dobj.name));
    appendPQExpBuffer(query, " ON ");
    appendPQExpBufferStr(query, fmtId(evtinfo->evtevent));
    appendPQExpBufferStr(query, " ");

    if (strcmp("", evtinfo->evttags) != 0)
    {
        appendPQExpBufferStr(query, "\n         WHEN TAG IN (");
        appendPQExpBufferStr(query, evtinfo->evttags);
        appendPQExpBufferStr(query, ") ");
    }

    appendPQExpBuffer(query, "\n   EXECUTE PROCEDURE ");
    appendPQExpBufferStr(query, evtinfo->evtfname);
    appendPQExpBuffer(query, "();\n");

    if (evtinfo->evtenabled != 'O')
    {
        appendPQExpBuffer(query, "\nALTER EVENT TRIGGER %s ",
                          fmtId(evtinfo->dobj.name));
        switch (evtinfo->evtenabled)
        {
            case 'D':
                appendPQExpBuffer(query, "DISABLE");
                break;
            case 'A':
                appendPQExpBuffer(query, "ENABLE ALWAYS");
                break;
            case 'R':
                appendPQExpBuffer(query, "ENABLE REPLICA");
                break;
            default:
                appendPQExpBuffer(query, "ENABLE");
                break;
        }
        appendPQExpBuffer(query, ";\n");
    }
    appendPQExpBuffer(labelq, "EVENT TRIGGER %s ",
                      fmtId(evtinfo->dobj.name));

    ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
                 evtinfo->dobj.name, NULL, NULL, evtinfo->evtowner, false,
                 "EVENT TRIGGER", SECTION_POST_DATA,
                 query->data, "", NULL, NULL, 0, NULL, NULL);

    dumpComment(fout, labelq->data,
                NULL, NULL,
                evtinfo->dobj.catId, 0, evtinfo->dobj.dumpId);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(labelq);
}

static void dumpExtension ( Archive fout,
ExtensionInfo extinfo 
) [static]

Definition at line 7827 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), binary_upgrade, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, _dumpableObject::dependencies, destroyPQExpBuffer(), DO_EXTENSION, _extensionInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), _extensionInfo::extcondition, _extensionInfo::extconfig, _extensionInfo::extversion, findObjectByDumpId(), fmtId(), free, i, _dumpableObject::name, _dumpableObject::nDeps, NULL, _dumpableObject::objType, pg_strdup(), _extensionInfo::relocatable, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    char       *qextname;

    /* Skip if not to be dumped */
    if (!extinfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

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

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

    if (!binary_upgrade)
    {
        /*
         * In a regular dump, we use IF NOT EXISTS so that there isn't a
         * problem if the extension already exists in the target database;
         * this is essential for installed-by-default extensions such as
         * plpgsql.
         *
         * In binary-upgrade mode, that doesn't work well, so instead we skip
         * built-in extensions based on their OIDs; see
         * selectDumpableExtension.
         */
        appendPQExpBuffer(q, "CREATE EXTENSION IF NOT EXISTS %s WITH SCHEMA %s;\n",
                          qextname, fmtId(extinfo->namespace));
    }
    else
    {
        int         i;
        int         n;

        appendPQExpBuffer(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");

        /*
         * We unconditionally create the extension, so we must drop it if it
         * exists.  This could happen if the user deleted 'plpgsql' and then
         * readded it, causing its oid to be greater than FirstNormalObjectId.
         * The FirstNormalObjectId test was kept to avoid repeatedly dropping
         * and recreating extensions like 'plpgsql'.
         */
        appendPQExpBuffer(q, "DROP EXTENSION IF EXISTS %s;\n", qextname);

        appendPQExpBuffer(q,
                          "SELECT binary_upgrade.create_empty_extension(");
        appendStringLiteralAH(q, extinfo->dobj.name, fout);
        appendPQExpBuffer(q, ", ");
        appendStringLiteralAH(q, extinfo->namespace, fout);
        appendPQExpBuffer(q, ", ");
        appendPQExpBuffer(q, "%s, ", extinfo->relocatable ? "true" : "false");
        appendStringLiteralAH(q, extinfo->extversion, fout);
        appendPQExpBuffer(q, ", ");

        /*
         * Note that we're pushing extconfig (an OID array) back into
         * pg_extension exactly as-is.  This is OK because pg_class OIDs are
         * preserved in binary upgrade.
         */
        if (strlen(extinfo->extconfig) > 2)
            appendStringLiteralAH(q, extinfo->extconfig, fout);
        else
            appendPQExpBuffer(q, "NULL");
        appendPQExpBuffer(q, ", ");
        if (strlen(extinfo->extcondition) > 2)
            appendStringLiteralAH(q, extinfo->extcondition, fout);
        else
            appendPQExpBuffer(q, "NULL");
        appendPQExpBuffer(q, ", ");
        appendPQExpBuffer(q, "ARRAY[");
        n = 0;
        for (i = 0; i < extinfo->dobj.nDeps; i++)
        {
            DumpableObject *extobj;

            extobj = findObjectByDumpId(extinfo->dobj.dependencies[i]);
            if (extobj && extobj->objType == DO_EXTENSION)
            {
                if (n++ > 0)
                    appendPQExpBuffer(q, ",");
                appendStringLiteralAH(q, extobj->name, fout);
            }
        }
        appendPQExpBuffer(q, "]::pg_catalog.text[]");
        appendPQExpBuffer(q, ");\n");
    }

    appendPQExpBuffer(labelq, "EXTENSION %s", qextname);

    ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
                 extinfo->dobj.name,
                 NULL, NULL,
                 "",
                 false, "EXTENSION", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Extension Comments and Security Labels */
    dumpComment(fout, labelq->data,
                NULL, "",
                extinfo->dobj.catId, 0, extinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 NULL, "",
                 extinfo->dobj.catId, 0, extinfo->dobj.dumpId);

    free(qextname);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpForeignDataWrapper ( Archive fout,
FdwInfo fdwinfo 
) [static]

Definition at line 11965 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _fdwInfo::dobj, _dumpableObject::dump, dumpACL(), dumpComment(), _dumpableObject::dumpId, _dumpableObject::ext_member, _fdwInfo::fdwacl, _fdwInfo::fdwhandler, _fdwInfo::fdwoptions, _fdwInfo::fdwvalidator, fmtId(), free, include_everything, _dumpableObject::name, NULL, pg_strdup(), _fdwInfo::rolname, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    char       *qfdwname;

    /* Skip if not to be dumped */
    if (!fdwinfo->dobj.dump || dataOnly)
        return;

    /*
     * FDWs that belong to an extension are dumped based on their "dump"
     * field. Otherwise omit them if we are only dumping some specific object.
     */
    if (!fdwinfo->dobj.ext_member)
        if (!include_everything)
            return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

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

    appendPQExpBuffer(q, "CREATE FOREIGN DATA WRAPPER %s",
                      qfdwname);

    if (strcmp(fdwinfo->fdwhandler, "-") != 0)
        appendPQExpBuffer(q, " HANDLER %s", fdwinfo->fdwhandler);

    if (strcmp(fdwinfo->fdwvalidator, "-") != 0)
        appendPQExpBuffer(q, " VALIDATOR %s", fdwinfo->fdwvalidator);

    if (strlen(fdwinfo->fdwoptions) > 0)
        appendPQExpBuffer(q, " OPTIONS (\n    %s\n)", fdwinfo->fdwoptions);

    appendPQExpBuffer(q, ";\n");

    appendPQExpBuffer(delq, "DROP FOREIGN DATA WRAPPER %s;\n",
                      qfdwname);

    appendPQExpBuffer(labelq, "FOREIGN DATA WRAPPER %s",
                      qfdwname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &fdwinfo->dobj, labelq->data);

    ArchiveEntry(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
                 fdwinfo->dobj.name,
                 NULL,
                 NULL,
                 fdwinfo->rolname,
                 false, "FOREIGN DATA WRAPPER", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Handle the ACL */
    dumpACL(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
            "FOREIGN DATA WRAPPER",
            qfdwname, NULL, fdwinfo->dobj.name,
            NULL, fdwinfo->rolname,
            fdwinfo->fdwacl);

    /* Dump Foreign Data Wrapper Comments */
    dumpComment(fout, labelq->data,
                NULL, fdwinfo->rolname,
                fdwinfo->dobj.catId, 0, fdwinfo->dobj.dumpId);

    free(qfdwname);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpForeignServer ( Archive fout,
ForeignServerInfo srvinfo 
) [static]

Definition at line 12047 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _foreignServerInfo::dobj, _dumpableObject::dump, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpUserMappings(), ExecuteSqlQueryForSingleRow(), fmtId(), free, include_everything, _dumpableObject::name, NULL, pg_strdup(), PQgetvalue(), _foreignServerInfo::rolname, SECTION_PRE_DATA, selectSourceSchema(), _foreignServerInfo::srvacl, _foreignServerInfo::srvfdw, _foreignServerInfo::srvoptions, _foreignServerInfo::srvtype, and _foreignServerInfo::srvversion.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PQExpBuffer query;
    PGresult   *res;
    char       *qsrvname;
    char       *fdwname;

    /* Skip if not to be dumped */
    if (!srvinfo->dobj.dump || dataOnly || !include_everything)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();
    query = createPQExpBuffer();

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

    /* look up the foreign-data wrapper */
    selectSourceSchema(fout, "pg_catalog");
    appendPQExpBuffer(query, "SELECT fdwname "
                      "FROM pg_foreign_data_wrapper w "
                      "WHERE w.oid = '%u'",
                      srvinfo->srvfdw);
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
    fdwname = PQgetvalue(res, 0, 0);

    appendPQExpBuffer(q, "CREATE SERVER %s", qsrvname);
    if (srvinfo->srvtype && strlen(srvinfo->srvtype) > 0)
    {
        appendPQExpBuffer(q, " TYPE ");
        appendStringLiteralAH(q, srvinfo->srvtype, fout);
    }
    if (srvinfo->srvversion && strlen(srvinfo->srvversion) > 0)
    {
        appendPQExpBuffer(q, " VERSION ");
        appendStringLiteralAH(q, srvinfo->srvversion, fout);
    }

    appendPQExpBuffer(q, " FOREIGN DATA WRAPPER ");
    appendPQExpBuffer(q, "%s", fmtId(fdwname));

    if (srvinfo->srvoptions && strlen(srvinfo->srvoptions) > 0)
        appendPQExpBuffer(q, " OPTIONS (\n    %s\n)", srvinfo->srvoptions);

    appendPQExpBuffer(q, ";\n");

    appendPQExpBuffer(delq, "DROP SERVER %s;\n",
                      qsrvname);

    appendPQExpBuffer(labelq, "SERVER %s", qsrvname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &srvinfo->dobj, labelq->data);

    ArchiveEntry(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
                 srvinfo->dobj.name,
                 NULL,
                 NULL,
                 srvinfo->rolname,
                 false, "SERVER", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Handle the ACL */
    dumpACL(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
            "FOREIGN SERVER",
            qsrvname, NULL, srvinfo->dobj.name,
            NULL, srvinfo->rolname,
            srvinfo->srvacl);

    /* Dump user mappings */
    dumpUserMappings(fout,
                     srvinfo->dobj.name, NULL,
                     srvinfo->rolname,
                     srvinfo->dobj.catId, srvinfo->dobj.dumpId);

    /* Dump Foreign Server Comments */
    dumpComment(fout, labelq->data,
                NULL, srvinfo->rolname,
                srvinfo->dobj.catId, 0, srvinfo->dobj.dumpId);

    free(qsrvname);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpFunc ( Archive fout,
FuncInfo finfo 
) [static]

Definition at line 9485 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, appendStringLiteralDQ(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), disable_dollar_quoting, _funcInfo::dobj, _dumpableObject::dump, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), ExecuteSqlQueryForSingleRow(), exit_horribly(), fmtId(), format_function_arguments(), format_function_arguments_old(), format_function_signature(), free, getFormattedTypeName(), i, _dumpableObject::name, _funcInfo::nargs, NULL, CatalogId::oid, parsePGArray(), pg_strcasecmp(), PQclear(), PQfnumber(), PQgetvalue(), _funcInfo::proacl, _funcInfo::prorettype, PROVOLATILE_IMMUTABLE, PROVOLATILE_STABLE, PROVOLATILE_VOLATILE, Archive::remoteVersion, _funcInfo::rolname, SECTION_PRE_DATA, selectSourceSchema(), write_msg(), and zeroAsOpaque.

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delqry;
    PQExpBuffer labelq;
    PQExpBuffer asPart;
    PGresult   *res;
    char       *funcsig;        /* identity signature */
    char       *funcfullsig;    /* full signature */
    char       *funcsig_tag;
    char       *proretset;
    char       *prosrc;
    char       *probin;
    char       *funcargs;
    char       *funciargs;
    char       *funcresult;
    char       *proallargtypes;
    char       *proargmodes;
    char       *proargnames;
    char       *proiswindow;
    char       *provolatile;
    char       *proisstrict;
    char       *prosecdef;
    char       *proleakproof;
    char       *proconfig;
    char       *procost;
    char       *prorows;
    char       *lanname;
    char       *rettypename;
    int         nallargs;
    char      **allargtypes = NULL;
    char      **argmodes = NULL;
    char      **argnames = NULL;
    char      **configitems = NULL;
    int         nconfigitems = 0;
    int         i;

    /* Skip if not to be dumped */
    if (!finfo->dobj.dump || dataOnly)
        return;

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delqry = createPQExpBuffer();
    labelq = createPQExpBuffer();
    asPart = createPQExpBuffer();

    /* Set proper schema search path so type references list correctly */
    selectSourceSchema(fout, finfo->dobj.namespace->dobj.name);

    /* Fetch function-specific details */
    if (fout->remoteVersion >= 90200)
    {
        /*
         * proleakproof was added at v9.2
         */
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                    "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
          "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
                     "pg_catalog.pg_get_function_result(oid) AS funcresult, "
                          "proiswindow, provolatile, proisstrict, prosecdef, "
                          "proleakproof, proconfig, procost, prorows, "
                          "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_catalog.pg_proc "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          finfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80400)
    {
        /*
         * In 8.4 and up we rely on pg_get_function_arguments and
         * pg_get_function_result instead of examining proallargtypes etc.
         */
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                    "pg_catalog.pg_get_function_arguments(oid) AS funcargs, "
          "pg_catalog.pg_get_function_identity_arguments(oid) AS funciargs, "
                     "pg_catalog.pg_get_function_result(oid) AS funcresult, "
                          "proiswindow, provolatile, proisstrict, prosecdef, "
                          "false AS proleakproof, "
                          " proconfig, procost, prorows, "
                          "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_catalog.pg_proc "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          finfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                          "proallargtypes, proargmodes, proargnames, "
                          "false AS proiswindow, "
                          "provolatile, proisstrict, prosecdef, "
                          "false AS proleakproof, "
                          "proconfig, procost, prorows, "
                          "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_catalog.pg_proc "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          finfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80100)
    {
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                          "proallargtypes, proargmodes, proargnames, "
                          "false AS proiswindow, "
                          "provolatile, proisstrict, prosecdef, "
                          "false AS proleakproof, "
                          "null AS proconfig, 0 AS procost, 0 AS prorows, "
                          "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_catalog.pg_proc "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          finfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80000)
    {
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                          "null AS proallargtypes, "
                          "null AS proargmodes, "
                          "proargnames, "
                          "false AS proiswindow, "
                          "provolatile, proisstrict, prosecdef, "
                          "false AS proleakproof, "
                          "null AS proconfig, 0 AS procost, 0 AS prorows, "
                          "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_catalog.pg_proc "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          finfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                          "null AS proallargtypes, "
                          "null AS proargmodes, "
                          "null AS proargnames, "
                          "false AS proiswindow, "
                          "provolatile, proisstrict, prosecdef, "
                          "false AS proleakproof, "
                          "null AS proconfig, 0 AS procost, 0 AS prorows, "
                          "(SELECT lanname FROM pg_catalog.pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_catalog.pg_proc "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          finfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                          "null AS proallargtypes, "
                          "null AS proargmodes, "
                          "null AS proargnames, "
                          "false AS proiswindow, "
             "case when proiscachable then 'i' else 'v' end AS provolatile, "
                          "proisstrict, "
                          "false AS prosecdef, "
                          "false AS proleakproof, "
                          "null AS proconfig, 0 AS procost, 0 AS prorows, "
          "(SELECT lanname FROM pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_proc "
                          "WHERE oid = '%u'::oid",
                          finfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query,
                          "SELECT proretset, prosrc, probin, "
                          "null AS proallargtypes, "
                          "null AS proargmodes, "
                          "null AS proargnames, "
                          "false AS proiswindow, "
             "CASE WHEN proiscachable THEN 'i' ELSE 'v' END AS provolatile, "
                          "false AS proisstrict, "
                          "false AS prosecdef, "
                          "false AS proleakproof, "
                          "NULL AS proconfig, 0 AS procost, 0 AS prorows, "
          "(SELECT lanname FROM pg_language WHERE oid = prolang) AS lanname "
                          "FROM pg_proc "
                          "WHERE oid = '%u'::oid",
                          finfo->dobj.catId.oid);
    }

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    proretset = PQgetvalue(res, 0, PQfnumber(res, "proretset"));
    prosrc = PQgetvalue(res, 0, PQfnumber(res, "prosrc"));
    probin = PQgetvalue(res, 0, PQfnumber(res, "probin"));
    if (fout->remoteVersion >= 80400)
    {
        funcargs = PQgetvalue(res, 0, PQfnumber(res, "funcargs"));
        funciargs = PQgetvalue(res, 0, PQfnumber(res, "funciargs"));
        funcresult = PQgetvalue(res, 0, PQfnumber(res, "funcresult"));
        proallargtypes = proargmodes = proargnames = NULL;
    }
    else
    {
        proallargtypes = PQgetvalue(res, 0, PQfnumber(res, "proallargtypes"));
        proargmodes = PQgetvalue(res, 0, PQfnumber(res, "proargmodes"));
        proargnames = PQgetvalue(res, 0, PQfnumber(res, "proargnames"));
        funcargs = funciargs = funcresult = NULL;
    }
    proiswindow = PQgetvalue(res, 0, PQfnumber(res, "proiswindow"));
    provolatile = PQgetvalue(res, 0, PQfnumber(res, "provolatile"));
    proisstrict = PQgetvalue(res, 0, PQfnumber(res, "proisstrict"));
    prosecdef = PQgetvalue(res, 0, PQfnumber(res, "prosecdef"));
    proleakproof = PQgetvalue(res, 0, PQfnumber(res, "proleakproof"));
    proconfig = PQgetvalue(res, 0, PQfnumber(res, "proconfig"));
    procost = PQgetvalue(res, 0, PQfnumber(res, "procost"));
    prorows = PQgetvalue(res, 0, PQfnumber(res, "prorows"));
    lanname = PQgetvalue(res, 0, PQfnumber(res, "lanname"));

    /*
     * See backend/commands/functioncmds.c for details of how the 'AS' clause
     * is used.  In 8.4 and up, an unused probin is NULL (here ""); previous
     * versions would set it to "-".  There are no known cases in which prosrc
     * is unused, so the tests below for "-" are probably useless.
     */
    if (probin[0] != '\0' && strcmp(probin, "-") != 0)
    {
        appendPQExpBuffer(asPart, "AS ");
        appendStringLiteralAH(asPart, probin, fout);
        if (strcmp(prosrc, "-") != 0)
        {
            appendPQExpBuffer(asPart, ", ");

            /*
             * where we have bin, use dollar quoting if allowed and src
             * contains quote or backslash; else use regular quoting.
             */
            if (disable_dollar_quoting ||
              (strchr(prosrc, '\'') == NULL && strchr(prosrc, '\\') == NULL))
                appendStringLiteralAH(asPart, prosrc, fout);
            else
                appendStringLiteralDQ(asPart, prosrc, NULL);
        }
    }
    else
    {
        if (strcmp(prosrc, "-") != 0)
        {
            appendPQExpBuffer(asPart, "AS ");
            /* with no bin, dollar quote src unconditionally if allowed */
            if (disable_dollar_quoting)
                appendStringLiteralAH(asPart, prosrc, fout);
            else
                appendStringLiteralDQ(asPart, prosrc, NULL);
        }
    }

    nallargs = finfo->nargs;    /* unless we learn different from allargs */

    if (proallargtypes && *proallargtypes)
    {
        int         nitems = 0;

        if (!parsePGArray(proallargtypes, &allargtypes, &nitems) ||
            nitems < finfo->nargs)
        {
            write_msg(NULL, "WARNING: could not parse proallargtypes array\n");
            if (allargtypes)
                free(allargtypes);
            allargtypes = NULL;
        }
        else
            nallargs = nitems;
    }

    if (proargmodes && *proargmodes)
    {
        int         nitems = 0;

        if (!parsePGArray(proargmodes, &argmodes, &nitems) ||
            nitems != nallargs)
        {
            write_msg(NULL, "WARNING: could not parse proargmodes array\n");
            if (argmodes)
                free(argmodes);
            argmodes = NULL;
        }
    }

    if (proargnames && *proargnames)
    {
        int         nitems = 0;

        if (!parsePGArray(proargnames, &argnames, &nitems) ||
            nitems != nallargs)
        {
            write_msg(NULL, "WARNING: could not parse proargnames array\n");
            if (argnames)
                free(argnames);
            argnames = NULL;
        }
    }

    if (proconfig && *proconfig)
    {
        if (!parsePGArray(proconfig, &configitems, &nconfigitems))
        {
            write_msg(NULL, "WARNING: could not parse proconfig array\n");
            if (configitems)
                free(configitems);
            configitems = NULL;
            nconfigitems = 0;
        }
    }

    if (funcargs)
    {
        /* 8.4 or later; we rely on server-side code for most of the work */
        funcfullsig = format_function_arguments(finfo, funcargs);
        funcsig = format_function_arguments(finfo, funciargs);
    }
    else
    {
        /* pre-8.4, do it ourselves */
        funcsig = format_function_arguments_old(fout,
                                                finfo, nallargs, allargtypes,
                                                argmodes, argnames);
        funcfullsig = funcsig;
    }

    funcsig_tag = format_function_signature(fout, finfo, false);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delqry, "DROP FUNCTION %s.%s;\n",
                      fmtId(finfo->dobj.namespace->dobj.name),
                      funcsig);

    appendPQExpBuffer(q, "CREATE FUNCTION %s ", funcfullsig);
    if (funcresult)
        appendPQExpBuffer(q, "RETURNS %s", funcresult);
    else
    {
        rettypename = getFormattedTypeName(fout, finfo->prorettype,
                                           zeroAsOpaque);
        appendPQExpBuffer(q, "RETURNS %s%s",
                          (proretset[0] == 't') ? "SETOF " : "",
                          rettypename);
        free(rettypename);
    }

    appendPQExpBuffer(q, "\n    LANGUAGE %s", fmtId(lanname));

    if (proiswindow[0] == 't')
        appendPQExpBuffer(q, " WINDOW");

    if (provolatile[0] != PROVOLATILE_VOLATILE)
    {
        if (provolatile[0] == PROVOLATILE_IMMUTABLE)
            appendPQExpBuffer(q, " IMMUTABLE");
        else if (provolatile[0] == PROVOLATILE_STABLE)
            appendPQExpBuffer(q, " STABLE");
        else if (provolatile[0] != PROVOLATILE_VOLATILE)
            exit_horribly(NULL, "unrecognized provolatile value for function \"%s\"\n",
                          finfo->dobj.name);
    }

    if (proisstrict[0] == 't')
        appendPQExpBuffer(q, " STRICT");

    if (prosecdef[0] == 't')
        appendPQExpBuffer(q, " SECURITY DEFINER");

    if (proleakproof[0] == 't')
        appendPQExpBuffer(q, " LEAKPROOF");

    /*
     * COST and ROWS are emitted only if present and not default, so as not to
     * break backwards-compatibility of the dump without need.  Keep this code
     * in sync with the defaults in functioncmds.c.
     */
    if (strcmp(procost, "0") != 0)
    {
        if (strcmp(lanname, "internal") == 0 || strcmp(lanname, "c") == 0)
        {
            /* default cost is 1 */
            if (strcmp(procost, "1") != 0)
                appendPQExpBuffer(q, " COST %s", procost);
        }
        else
        {
            /* default cost is 100 */
            if (strcmp(procost, "100") != 0)
                appendPQExpBuffer(q, " COST %s", procost);
        }
    }
    if (proretset[0] == 't' &&
        strcmp(prorows, "0") != 0 && strcmp(prorows, "1000") != 0)
        appendPQExpBuffer(q, " ROWS %s", prorows);

    for (i = 0; i < nconfigitems; i++)
    {
        /* we feel free to scribble on configitems[] here */
        char       *configitem = configitems[i];
        char       *pos;

        pos = strchr(configitem, '=');
        if (pos == NULL)
            continue;
        *pos++ = '\0';
        appendPQExpBuffer(q, "\n    SET %s TO ", fmtId(configitem));

        /*
         * Some GUC variable names are 'LIST' type and hence must not be
         * quoted.
         */
        if (pg_strcasecmp(configitem, "DateStyle") == 0
            || pg_strcasecmp(configitem, "search_path") == 0)
            appendPQExpBuffer(q, "%s", pos);
        else
            appendStringLiteralAH(q, pos, fout);
    }

    appendPQExpBuffer(q, "\n    %s;\n", asPart->data);

    appendPQExpBuffer(labelq, "FUNCTION %s", funcsig);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &finfo->dobj, labelq->data);

    ArchiveEntry(fout, finfo->dobj.catId, finfo->dobj.dumpId,
                 funcsig_tag,
                 finfo->dobj.namespace->dobj.name,
                 NULL,
                 finfo->rolname, false,
                 "FUNCTION", SECTION_PRE_DATA,
                 q->data, delqry->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Function Comments and Security Labels */
    dumpComment(fout, labelq->data,
                finfo->dobj.namespace->dobj.name, finfo->rolname,
                finfo->dobj.catId, 0, finfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 finfo->dobj.namespace->dobj.name, finfo->rolname,
                 finfo->dobj.catId, 0, finfo->dobj.dumpId);

    dumpACL(fout, finfo->dobj.catId, finfo->dobj.dumpId, "FUNCTION",
            funcsig, NULL, funcsig_tag,
            finfo->dobj.namespace->dobj.name,
            finfo->rolname, finfo->proacl);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delqry);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(asPart);
    free(funcsig);
    free(funcsig_tag);
    if (allargtypes)
        free(allargtypes);
    if (argmodes)
        free(argmodes);
    if (argnames)
        free(argnames);
    if (configitems)
        free(configitems);
}

static void dumpIndex ( Archive fout,
IndxInfo indxinfo 
) [static]

Definition at line 13466 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_set_pg_class_oids(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _indxInfo::dobj, dumpComment(), _dumpableObject::dumpId, fmtId(), _indxInfo::indexconstraint, _indxInfo::indexdef, _indxInfo::indextable, _indxInfo::indisclustered, _dumpableObject::name, NULL, CatalogId::oid, _tableInfo::rolname, SECTION_POST_DATA, and _indxInfo::tablespace.

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = indxinfo->indextable;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;

    if (dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    appendPQExpBuffer(labelq, "INDEX %s",
                      fmtId(indxinfo->dobj.name));

    /*
     * If there's an associated constraint, don't dump the index per se, but
     * do dump any comment for it.  (This is safe because dependency ordering
     * will have ensured the constraint is emitted first.)
     */
    if (indxinfo->indexconstraint == 0)
    {
        if (binary_upgrade)
            binary_upgrade_set_pg_class_oids(fout, q,
                                             indxinfo->dobj.catId.oid, true);

        /* Plain secondary index */
        appendPQExpBuffer(q, "%s;\n", indxinfo->indexdef);

        /* If the index is clustered, we need to record that. */
        if (indxinfo->indisclustered)
        {
            appendPQExpBuffer(q, "\nALTER TABLE %s CLUSTER",
                              fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(q, " ON %s;\n",
                              fmtId(indxinfo->dobj.name));
        }

        /*
         * DROP must be fully qualified in case same name appears in
         * pg_catalog
         */
        appendPQExpBuffer(delq, "DROP INDEX %s.",
                          fmtId(tbinfo->dobj.namespace->dobj.name));
        appendPQExpBuffer(delq, "%s;\n",
                          fmtId(indxinfo->dobj.name));

        ArchiveEntry(fout, indxinfo->dobj.catId, indxinfo->dobj.dumpId,
                     indxinfo->dobj.name,
                     tbinfo->dobj.namespace->dobj.name,
                     indxinfo->tablespace,
                     tbinfo->rolname, false,
                     "INDEX", SECTION_POST_DATA,
                     q->data, delq->data, NULL,
                     NULL, 0,
                     NULL, NULL);
    }

    /* Dump Index Comments */
    dumpComment(fout, labelq->data,
                tbinfo->dobj.namespace->dobj.name,
                tbinfo->rolname,
                indxinfo->dobj.catId, 0, indxinfo->dobj.dumpId);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpNamespace ( Archive fout,
NamespaceInfo nspinfo 
) [static]

Definition at line 7764 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _namespaceInfo::dobj, _dumpableObject::dump, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), fmtId(), free, _dumpableObject::name, _namespaceInfo::nspacl, NULL, pg_strdup(), _namespaceInfo::rolname, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    char       *qnspname;

    /* Skip if not to be dumped */
    if (!nspinfo->dobj.dump || dataOnly)
        return;

    /* don't dump dummy namespace from pre-7.3 source */
    if (strlen(nspinfo->dobj.name) == 0)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

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

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

    appendPQExpBuffer(q, "CREATE SCHEMA %s;\n", qnspname);

    appendPQExpBuffer(labelq, "SCHEMA %s", qnspname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &nspinfo->dobj, labelq->data);

    ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
                 nspinfo->dobj.name,
                 NULL, NULL,
                 nspinfo->rolname,
                 false, "SCHEMA", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Schema Comments and Security Labels */
    dumpComment(fout, labelq->data,
                NULL, nspinfo->rolname,
                nspinfo->dobj.catId, 0, nspinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 NULL, nspinfo->rolname,
                 nspinfo->dobj.catId, 0, nspinfo->dobj.dumpId);

    dumpACL(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId, "SCHEMA",
            qnspname, NULL, nspinfo->dobj.name, NULL,
            nspinfo->rolname, nspinfo->nspacl);

    free(qnspname);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpOpclass ( Archive fout,
OpclassInfo opcinfo 
) [static]

Definition at line 10475 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _opclassInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fmtId(), free, i, _dumpableObject::name, NULL, CatalogId::oid, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, resetPQExpBuffer(), _opclassInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PGresult   *res;
    int         ntups;
    int         i_opcintype;
    int         i_opckeytype;
    int         i_opcdefault;
    int         i_opcfamily;
    int         i_opcfamilyname;
    int         i_opcfamilynsp;
    int         i_amname;
    int         i_amopstrategy;
    int         i_amopreqcheck;
    int         i_amopopr;
    int         i_sortfamily;
    int         i_sortfamilynsp;
    int         i_amprocnum;
    int         i_amproc;
    int         i_amproclefttype;
    int         i_amprocrighttype;
    char       *opcintype;
    char       *opckeytype;
    char       *opcdefault;
    char       *opcfamily;
    char       *opcfamilyname;
    char       *opcfamilynsp;
    char       *amname;
    char       *amopstrategy;
    char       *amopreqcheck;
    char       *amopopr;
    char       *sortfamily;
    char       *sortfamilynsp;
    char       *amprocnum;
    char       *amproc;
    char       *amproclefttype;
    char       *amprocrighttype;
    bool        needComma;
    int         i;

    /* Skip if not to be dumped */
    if (!opcinfo->dobj.dump || dataOnly)
        return;

    /*
     * XXX currently we do not implement dumping of operator classes from
     * pre-7.3 databases.  This could be done but it seems not worth the
     * trouble.
     */
    if (fout->remoteVersion < 70300)
        return;

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /* Make sure we are in proper schema so regoperator works correctly */
    selectSourceSchema(fout, opcinfo->dobj.namespace->dobj.name);

    /* Get additional fields from the pg_opclass row */
    if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query, "SELECT opcintype::pg_catalog.regtype, "
                          "opckeytype::pg_catalog.regtype, "
                          "opcdefault, opcfamily, "
                          "opfname AS opcfamilyname, "
                          "nspname AS opcfamilynsp, "
                          "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
                          "FROM pg_catalog.pg_opclass c "
                   "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
               "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
                          "WHERE c.oid = '%u'::pg_catalog.oid",
                          opcinfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT opcintype::pg_catalog.regtype, "
                          "opckeytype::pg_catalog.regtype, "
                          "opcdefault, NULL AS opcfamily, "
                          "NULL AS opcfamilyname, "
                          "NULL AS opcfamilynsp, "
        "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcamid) AS amname "
                          "FROM pg_catalog.pg_opclass "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          opcinfo->dobj.catId.oid);
    }

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    i_opcintype = PQfnumber(res, "opcintype");
    i_opckeytype = PQfnumber(res, "opckeytype");
    i_opcdefault = PQfnumber(res, "opcdefault");
    i_opcfamily = PQfnumber(res, "opcfamily");
    i_opcfamilyname = PQfnumber(res, "opcfamilyname");
    i_opcfamilynsp = PQfnumber(res, "opcfamilynsp");
    i_amname = PQfnumber(res, "amname");

    opcintype = PQgetvalue(res, 0, i_opcintype);
    opckeytype = PQgetvalue(res, 0, i_opckeytype);
    opcdefault = PQgetvalue(res, 0, i_opcdefault);
    /* opcfamily will still be needed after we PQclear res */
    opcfamily = pg_strdup(PQgetvalue(res, 0, i_opcfamily));
    opcfamilyname = PQgetvalue(res, 0, i_opcfamilyname);
    opcfamilynsp = PQgetvalue(res, 0, i_opcfamilynsp);
    /* amname will still be needed after we PQclear res */
    amname = pg_strdup(PQgetvalue(res, 0, i_amname));

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP OPERATOR CLASS %s",
                      fmtId(opcinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s",
                      fmtId(opcinfo->dobj.name));
    appendPQExpBuffer(delq, " USING %s;\n",
                      fmtId(amname));

    /* Build the fixed portion of the CREATE command */
    appendPQExpBuffer(q, "CREATE OPERATOR CLASS %s\n    ",
                      fmtId(opcinfo->dobj.name));
    if (strcmp(opcdefault, "t") == 0)
        appendPQExpBuffer(q, "DEFAULT ");
    appendPQExpBuffer(q, "FOR TYPE %s USING %s",
                      opcintype,
                      fmtId(amname));
    if (strlen(opcfamilyname) > 0 &&
        (strcmp(opcfamilyname, opcinfo->dobj.name) != 0 ||
         strcmp(opcfamilynsp, opcinfo->dobj.namespace->dobj.name) != 0))
    {
        appendPQExpBuffer(q, " FAMILY ");
        if (strcmp(opcfamilynsp, opcinfo->dobj.namespace->dobj.name) != 0)
            appendPQExpBuffer(q, "%s.", fmtId(opcfamilynsp));
        appendPQExpBuffer(q, "%s", fmtId(opcfamilyname));
    }
    appendPQExpBuffer(q, " AS\n    ");

    needComma = false;

    if (strcmp(opckeytype, "-") != 0)
    {
        appendPQExpBuffer(q, "STORAGE %s",
                          opckeytype);
        needComma = true;
    }

    PQclear(res);

    /*
     * Now fetch and print the OPERATOR entries (pg_amop rows).
     *
     * Print only those opfamily members that are tied to the opclass by
     * pg_depend entries.
     *
     * XXX RECHECK is gone as of 8.4, but we'll still print it if dumping an
     * older server's opclass in which it is used.  This is to avoid
     * hard-to-detect breakage if a newer pg_dump is used to dump from an
     * older server and then reload into that old version.  This can go away
     * once 8.3 is so old as to not be of interest to anyone.
     */
    resetPQExpBuffer(query);

    if (fout->remoteVersion >= 90100)
    {
        appendPQExpBuffer(query, "SELECT amopstrategy, false AS amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "opfname AS sortfamily, "
                          "nspname AS sortfamilynsp "
                   "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
                          "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
              "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
               "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
           "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                          "AND amopfamily = '%s'::pg_catalog.oid "
                          "ORDER BY amopstrategy",
                          opcinfo->dobj.catId.oid,
                          opcfamily);
    }
    else if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query, "SELECT amopstrategy, false AS amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "NULL AS sortfamily, "
                          "NULL AS sortfamilynsp "
                          "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
           "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                   "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
                          "AND objid = ao.oid "
                          "ORDER BY amopstrategy",
                          opcinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query, "SELECT amopstrategy, amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "NULL AS sortfamily, "
                          "NULL AS sortfamilynsp "
                          "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
           "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                   "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
                          "AND objid = ao.oid "
                          "ORDER BY amopstrategy",
                          opcinfo->dobj.catId.oid);
    }
    else
    {
        /*
         * Here, we print all entries since there are no opfamilies and hence
         * no loose operators to worry about.
         */
        appendPQExpBuffer(query, "SELECT amopstrategy, amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "NULL AS sortfamily, "
                          "NULL AS sortfamilynsp "
                          "FROM pg_catalog.pg_amop "
                          "WHERE amopclaid = '%u'::pg_catalog.oid "
                          "ORDER BY amopstrategy",
                          opcinfo->dobj.catId.oid);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    i_amopstrategy = PQfnumber(res, "amopstrategy");
    i_amopreqcheck = PQfnumber(res, "amopreqcheck");
    i_amopopr = PQfnumber(res, "amopopr");
    i_sortfamily = PQfnumber(res, "sortfamily");
    i_sortfamilynsp = PQfnumber(res, "sortfamilynsp");

    for (i = 0; i < ntups; i++)
    {
        amopstrategy = PQgetvalue(res, i, i_amopstrategy);
        amopreqcheck = PQgetvalue(res, i, i_amopreqcheck);
        amopopr = PQgetvalue(res, i, i_amopopr);
        sortfamily = PQgetvalue(res, i, i_sortfamily);
        sortfamilynsp = PQgetvalue(res, i, i_sortfamilynsp);

        if (needComma)
            appendPQExpBuffer(q, " ,\n    ");

        appendPQExpBuffer(q, "OPERATOR %s %s",
                          amopstrategy, amopopr);

        if (strlen(sortfamily) > 0)
        {
            appendPQExpBuffer(q, " FOR ORDER BY ");
            if (strcmp(sortfamilynsp, opcinfo->dobj.namespace->dobj.name) != 0)
                appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
            appendPQExpBuffer(q, "%s", fmtId(sortfamily));
        }

        if (strcmp(amopreqcheck, "t") == 0)
            appendPQExpBuffer(q, " RECHECK");

        needComma = true;
    }

    PQclear(res);

    /*
     * Now fetch and print the FUNCTION entries (pg_amproc rows).
     *
     * Print only those opfamily members that are tied to the opclass by
     * pg_depend entries.
     *
     * We print the amproclefttype/amprocrighttype even though in most cases
     * the backend could deduce the right values, because of the corner case
     * of a btree sort support function for a cross-type comparison.  That's
     * only allowed in 9.2 and later, but for simplicity print them in all
     * versions that have the columns.
     */
    resetPQExpBuffer(query);

    if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query, "SELECT amprocnum, "
                          "amproc::pg_catalog.regprocedure, "
                          "amproclefttype::pg_catalog.regtype, "
                          "amprocrighttype::pg_catalog.regtype "
                        "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
           "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
                          "AND objid = ap.oid "
                          "ORDER BY amprocnum",
                          opcinfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT amprocnum, "
                          "amproc::pg_catalog.regprocedure, "
                          "'' AS amproclefttype, "
                          "'' AS amprocrighttype "
                          "FROM pg_catalog.pg_amproc "
                          "WHERE amopclaid = '%u'::pg_catalog.oid "
                          "ORDER BY amprocnum",
                          opcinfo->dobj.catId.oid);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    i_amprocnum = PQfnumber(res, "amprocnum");
    i_amproc = PQfnumber(res, "amproc");
    i_amproclefttype = PQfnumber(res, "amproclefttype");
    i_amprocrighttype = PQfnumber(res, "amprocrighttype");

    for (i = 0; i < ntups; i++)
    {
        amprocnum = PQgetvalue(res, i, i_amprocnum);
        amproc = PQgetvalue(res, i, i_amproc);
        amproclefttype = PQgetvalue(res, i, i_amproclefttype);
        amprocrighttype = PQgetvalue(res, i, i_amprocrighttype);

        if (needComma)
            appendPQExpBuffer(q, " ,\n    ");

        appendPQExpBuffer(q, "FUNCTION %s", amprocnum);

        if (*amproclefttype && *amprocrighttype)
            appendPQExpBuffer(q, " (%s, %s)", amproclefttype, amprocrighttype);

        appendPQExpBuffer(q, " %s", amproc);

        needComma = true;
    }

    PQclear(res);

    appendPQExpBuffer(q, ";\n");

    appendPQExpBuffer(labelq, "OPERATOR CLASS %s",
                      fmtId(opcinfo->dobj.name));
    appendPQExpBuffer(labelq, " USING %s",
                      fmtId(amname));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &opcinfo->dobj, labelq->data);

    ArchiveEntry(fout, opcinfo->dobj.catId, opcinfo->dobj.dumpId,
                 opcinfo->dobj.name,
                 opcinfo->dobj.namespace->dobj.name,
                 NULL,
                 opcinfo->rolname,
                 false, "OPERATOR CLASS", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Operator Class Comments */
    dumpComment(fout, labelq->data,
                NULL, opcinfo->rolname,
                opcinfo->dobj.catId, 0, opcinfo->dobj.dumpId);

    free(amname);
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpOpfamily ( Archive fout,
OpfamilyInfo opfinfo 
) [static]

Definition at line 10852 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _opfamilyInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fmtId(), free, i, _dumpableObject::name, NULL, CatalogId::oid, pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, resetPQExpBuffer(), _opfamilyInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PGresult   *res;
    PGresult   *res_ops;
    PGresult   *res_procs;
    int         ntups;
    int         i_amname;
    int         i_amopstrategy;
    int         i_amopreqcheck;
    int         i_amopopr;
    int         i_sortfamily;
    int         i_sortfamilynsp;
    int         i_amprocnum;
    int         i_amproc;
    int         i_amproclefttype;
    int         i_amprocrighttype;
    char       *amname;
    char       *amopstrategy;
    char       *amopreqcheck;
    char       *amopopr;
    char       *sortfamily;
    char       *sortfamilynsp;
    char       *amprocnum;
    char       *amproc;
    char       *amproclefttype;
    char       *amprocrighttype;
    bool        needComma;
    int         i;

    /* Skip if not to be dumped */
    if (!opfinfo->dobj.dump || dataOnly)
        return;

    /*
     * We want to dump the opfamily only if (1) it contains "loose" operators
     * or functions, or (2) it contains an opclass with a different name or
     * owner.  Otherwise it's sufficient to let it be created during creation
     * of the contained opclass, and not dumping it improves portability of
     * the dump.  Since we have to fetch the loose operators/funcs anyway, do
     * that first.
     */

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /* Make sure we are in proper schema so regoperator works correctly */
    selectSourceSchema(fout, opfinfo->dobj.namespace->dobj.name);

    /*
     * Fetch only those opfamily members that are tied directly to the
     * opfamily by pg_depend entries.
     *
     * XXX RECHECK is gone as of 8.4, but we'll still print it if dumping an
     * older server's opclass in which it is used.  This is to avoid
     * hard-to-detect breakage if a newer pg_dump is used to dump from an
     * older server and then reload into that old version.  This can go away
     * once 8.3 is so old as to not be of interest to anyone.
     */
    if (fout->remoteVersion >= 90100)
    {
        appendPQExpBuffer(query, "SELECT amopstrategy, false AS amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "opfname AS sortfamily, "
                          "nspname AS sortfamilynsp "
                   "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
                          "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
              "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
               "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
          "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                          "AND amopfamily = '%u'::pg_catalog.oid "
                          "ORDER BY amopstrategy",
                          opfinfo->dobj.catId.oid,
                          opfinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query, "SELECT amopstrategy, false AS amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "NULL AS sortfamily, "
                          "NULL AS sortfamilynsp "
                          "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
          "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                   "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
                          "AND objid = ao.oid "
                          "ORDER BY amopstrategy",
                          opfinfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT amopstrategy, amopreqcheck, "
                          "amopopr::pg_catalog.regoperator, "
                          "NULL AS sortfamily, "
                          "NULL AS sortfamilynsp "
                          "FROM pg_catalog.pg_amop ao, pg_catalog.pg_depend "
          "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
                          "AND refobjid = '%u'::pg_catalog.oid "
                   "AND classid = 'pg_catalog.pg_amop'::pg_catalog.regclass "
                          "AND objid = ao.oid "
                          "ORDER BY amopstrategy",
                          opfinfo->dobj.catId.oid);
    }

    res_ops = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    resetPQExpBuffer(query);

    appendPQExpBuffer(query, "SELECT amprocnum, "
                      "amproc::pg_catalog.regprocedure, "
                      "amproclefttype::pg_catalog.regtype, "
                      "amprocrighttype::pg_catalog.regtype "
                      "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
          "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
                      "AND refobjid = '%u'::pg_catalog.oid "
                 "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
                      "AND objid = ap.oid "
                      "ORDER BY amprocnum",
                      opfinfo->dobj.catId.oid);

    res_procs = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    if (PQntuples(res_ops) == 0 && PQntuples(res_procs) == 0)
    {
        /* No loose members, so check contained opclasses */
        resetPQExpBuffer(query);

        appendPQExpBuffer(query, "SELECT 1 "
                          "FROM pg_catalog.pg_opclass c, pg_catalog.pg_opfamily f, pg_catalog.pg_depend "
                          "WHERE f.oid = '%u'::pg_catalog.oid "
            "AND refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
                          "AND refobjid = f.oid "
                "AND classid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
                          "AND objid = c.oid "
                          "AND (opcname != opfname OR opcnamespace != opfnamespace OR opcowner != opfowner) "
                          "LIMIT 1",
                          opfinfo->dobj.catId.oid);

        res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

        if (PQntuples(res) == 0)
        {
            /* no need to dump it, so bail out */
            PQclear(res);
            PQclear(res_ops);
            PQclear(res_procs);
            destroyPQExpBuffer(query);
            destroyPQExpBuffer(q);
            destroyPQExpBuffer(delq);
            destroyPQExpBuffer(labelq);
            return;
        }

        PQclear(res);
    }

    /* Get additional fields from the pg_opfamily row */
    resetPQExpBuffer(query);

    appendPQExpBuffer(query, "SELECT "
     "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
                      "FROM pg_catalog.pg_opfamily "
                      "WHERE oid = '%u'::pg_catalog.oid",
                      opfinfo->dobj.catId.oid);

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    i_amname = PQfnumber(res, "amname");

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

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP OPERATOR FAMILY %s",
                      fmtId(opfinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s",
                      fmtId(opfinfo->dobj.name));
    appendPQExpBuffer(delq, " USING %s;\n",
                      fmtId(amname));

    /* Build the fixed portion of the CREATE command */
    appendPQExpBuffer(q, "CREATE OPERATOR FAMILY %s",
                      fmtId(opfinfo->dobj.name));
    appendPQExpBuffer(q, " USING %s;\n",
                      fmtId(amname));

    PQclear(res);

    /* Do we need an ALTER to add loose members? */
    if (PQntuples(res_ops) > 0 || PQntuples(res_procs) > 0)
    {
        appendPQExpBuffer(q, "ALTER OPERATOR FAMILY %s",
                          fmtId(opfinfo->dobj.name));
        appendPQExpBuffer(q, " USING %s ADD\n    ",
                          fmtId(amname));

        needComma = false;

        /*
         * Now fetch and print the OPERATOR entries (pg_amop rows).
         */
        ntups = PQntuples(res_ops);

        i_amopstrategy = PQfnumber(res_ops, "amopstrategy");
        i_amopreqcheck = PQfnumber(res_ops, "amopreqcheck");
        i_amopopr = PQfnumber(res_ops, "amopopr");
        i_sortfamily = PQfnumber(res_ops, "sortfamily");
        i_sortfamilynsp = PQfnumber(res_ops, "sortfamilynsp");

        for (i = 0; i < ntups; i++)
        {
            amopstrategy = PQgetvalue(res_ops, i, i_amopstrategy);
            amopreqcheck = PQgetvalue(res_ops, i, i_amopreqcheck);
            amopopr = PQgetvalue(res_ops, i, i_amopopr);
            sortfamily = PQgetvalue(res_ops, i, i_sortfamily);
            sortfamilynsp = PQgetvalue(res_ops, i, i_sortfamilynsp);

            if (needComma)
                appendPQExpBuffer(q, " ,\n    ");

            appendPQExpBuffer(q, "OPERATOR %s %s",
                              amopstrategy, amopopr);

            if (strlen(sortfamily) > 0)
            {
                appendPQExpBuffer(q, " FOR ORDER BY ");
                if (strcmp(sortfamilynsp, opfinfo->dobj.namespace->dobj.name) != 0)
                    appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
                appendPQExpBuffer(q, "%s", fmtId(sortfamily));
            }

            if (strcmp(amopreqcheck, "t") == 0)
                appendPQExpBuffer(q, " RECHECK");

            needComma = true;
        }

        /*
         * Now fetch and print the FUNCTION entries (pg_amproc rows).
         */
        ntups = PQntuples(res_procs);

        i_amprocnum = PQfnumber(res_procs, "amprocnum");
        i_amproc = PQfnumber(res_procs, "amproc");
        i_amproclefttype = PQfnumber(res_procs, "amproclefttype");
        i_amprocrighttype = PQfnumber(res_procs, "amprocrighttype");

        for (i = 0; i < ntups; i++)
        {
            amprocnum = PQgetvalue(res_procs, i, i_amprocnum);
            amproc = PQgetvalue(res_procs, i, i_amproc);
            amproclefttype = PQgetvalue(res_procs, i, i_amproclefttype);
            amprocrighttype = PQgetvalue(res_procs, i, i_amprocrighttype);

            if (needComma)
                appendPQExpBuffer(q, " ,\n    ");

            appendPQExpBuffer(q, "FUNCTION %s (%s, %s) %s",
                              amprocnum, amproclefttype, amprocrighttype,
                              amproc);

            needComma = true;
        }

        appendPQExpBuffer(q, ";\n");
    }

    appendPQExpBuffer(labelq, "OPERATOR FAMILY %s",
                      fmtId(opfinfo->dobj.name));
    appendPQExpBuffer(labelq, " USING %s",
                      fmtId(amname));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &opfinfo->dobj, labelq->data);

    ArchiveEntry(fout, opfinfo->dobj.catId, opfinfo->dobj.dumpId,
                 opfinfo->dobj.name,
                 opfinfo->dobj.namespace->dobj.name,
                 NULL,
                 opfinfo->rolname,
                 false, "OPERATOR FAMILY", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Operator Family Comments */
    dumpComment(fout, labelq->data,
                NULL, opfinfo->rolname,
                opfinfo->dobj.catId, 0, opfinfo->dobj.dumpId);

    free(amname);
    PQclear(res_ops);
    PQclear(res_procs);
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpOpr ( Archive fout,
OprInfo oprinfo 
) [static]

Definition at line 10106 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, convertOperatorReference(), convertRegProcReference(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _oprInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQueryForSingleRow(), fmtId(), _dumpableObject::name, name, NULL, CatalogId::oid, OidIsValid, _oprInfo::oprcode, PQclear(), PQfnumber(), PQgetvalue(), Archive::remoteVersion, _oprInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer query;
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PQExpBuffer oprid;
    PQExpBuffer details;
    const char *name;
    PGresult   *res;
    int         i_oprkind;
    int         i_oprcode;
    int         i_oprleft;
    int         i_oprright;
    int         i_oprcom;
    int         i_oprnegate;
    int         i_oprrest;
    int         i_oprjoin;
    int         i_oprcanmerge;
    int         i_oprcanhash;
    char       *oprkind;
    char       *oprcode;
    char       *oprleft;
    char       *oprright;
    char       *oprcom;
    char       *oprnegate;
    char       *oprrest;
    char       *oprjoin;
    char       *oprcanmerge;
    char       *oprcanhash;

    /* Skip if not to be dumped */
    if (!oprinfo->dobj.dump || dataOnly)
        return;

    /*
     * some operators are invalid because they were the result of user
     * defining operators before commutators exist
     */
    if (!OidIsValid(oprinfo->oprcode))
        return;

    query = createPQExpBuffer();
    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();
    oprid = createPQExpBuffer();
    details = createPQExpBuffer();

    /* Make sure we are in proper schema so regoperator works correctly */
    selectSourceSchema(fout, oprinfo->dobj.namespace->dobj.name);

    if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query, "SELECT oprkind, "
                          "oprcode::pg_catalog.regprocedure, "
                          "oprleft::pg_catalog.regtype, "
                          "oprright::pg_catalog.regtype, "
                          "oprcom::pg_catalog.regoperator, "
                          "oprnegate::pg_catalog.regoperator, "
                          "oprrest::pg_catalog.regprocedure, "
                          "oprjoin::pg_catalog.regprocedure, "
                          "oprcanmerge, oprcanhash "
                          "FROM pg_catalog.pg_operator "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          oprinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT oprkind, "
                          "oprcode::pg_catalog.regprocedure, "
                          "oprleft::pg_catalog.regtype, "
                          "oprright::pg_catalog.regtype, "
                          "oprcom::pg_catalog.regoperator, "
                          "oprnegate::pg_catalog.regoperator, "
                          "oprrest::pg_catalog.regprocedure, "
                          "oprjoin::pg_catalog.regprocedure, "
                          "(oprlsortop != 0) AS oprcanmerge, "
                          "oprcanhash "
                          "FROM pg_catalog.pg_operator "
                          "WHERE oid = '%u'::pg_catalog.oid",
                          oprinfo->dobj.catId.oid);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT oprkind, oprcode, "
                          "CASE WHEN oprleft = 0 THEN '-' "
                          "ELSE format_type(oprleft, NULL) END AS oprleft, "
                          "CASE WHEN oprright = 0 THEN '-' "
                          "ELSE format_type(oprright, NULL) END AS oprright, "
                          "oprcom, oprnegate, oprrest, oprjoin, "
                          "(oprlsortop != 0) AS oprcanmerge, "
                          "oprcanhash "
                          "FROM pg_operator "
                          "WHERE oid = '%u'::oid",
                          oprinfo->dobj.catId.oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT oprkind, oprcode, "
                          "CASE WHEN oprleft = 0 THEN '-'::name "
                          "ELSE (SELECT typname FROM pg_type WHERE oid = oprleft) END AS oprleft, "
                          "CASE WHEN oprright = 0 THEN '-'::name "
                          "ELSE (SELECT typname FROM pg_type WHERE oid = oprright) END AS oprright, "
                          "oprcom, oprnegate, oprrest, oprjoin, "
                          "(oprlsortop != 0) AS oprcanmerge, "
                          "oprcanhash "
                          "FROM pg_operator "
                          "WHERE oid = '%u'::oid",
                          oprinfo->dobj.catId.oid);
    }

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    i_oprkind = PQfnumber(res, "oprkind");
    i_oprcode = PQfnumber(res, "oprcode");
    i_oprleft = PQfnumber(res, "oprleft");
    i_oprright = PQfnumber(res, "oprright");
    i_oprcom = PQfnumber(res, "oprcom");
    i_oprnegate = PQfnumber(res, "oprnegate");
    i_oprrest = PQfnumber(res, "oprrest");
    i_oprjoin = PQfnumber(res, "oprjoin");
    i_oprcanmerge = PQfnumber(res, "oprcanmerge");
    i_oprcanhash = PQfnumber(res, "oprcanhash");

    oprkind = PQgetvalue(res, 0, i_oprkind);
    oprcode = PQgetvalue(res, 0, i_oprcode);
    oprleft = PQgetvalue(res, 0, i_oprleft);
    oprright = PQgetvalue(res, 0, i_oprright);
    oprcom = PQgetvalue(res, 0, i_oprcom);
    oprnegate = PQgetvalue(res, 0, i_oprnegate);
    oprrest = PQgetvalue(res, 0, i_oprrest);
    oprjoin = PQgetvalue(res, 0, i_oprjoin);
    oprcanmerge = PQgetvalue(res, 0, i_oprcanmerge);
    oprcanhash = PQgetvalue(res, 0, i_oprcanhash);

    appendPQExpBuffer(details, "    PROCEDURE = %s",
                      convertRegProcReference(fout, oprcode));

    appendPQExpBuffer(oprid, "%s (",
                      oprinfo->dobj.name);

    /*
     * right unary means there's a left arg and left unary means there's a
     * right arg
     */
    if (strcmp(oprkind, "r") == 0 ||
        strcmp(oprkind, "b") == 0)
    {
        if (fout->remoteVersion >= 70100)
            name = oprleft;
        else
            name = fmtId(oprleft);
        appendPQExpBuffer(details, ",\n    LEFTARG = %s", name);
        appendPQExpBuffer(oprid, "%s", name);
    }
    else
        appendPQExpBuffer(oprid, "NONE");

    if (strcmp(oprkind, "l") == 0 ||
        strcmp(oprkind, "b") == 0)
    {
        if (fout->remoteVersion >= 70100)
            name = oprright;
        else
            name = fmtId(oprright);
        appendPQExpBuffer(details, ",\n    RIGHTARG = %s", name);
        appendPQExpBuffer(oprid, ", %s)", name);
    }
    else
        appendPQExpBuffer(oprid, ", NONE)");

    name = convertOperatorReference(fout, oprcom);
    if (name)
        appendPQExpBuffer(details, ",\n    COMMUTATOR = %s", name);

    name = convertOperatorReference(fout, oprnegate);
    if (name)
        appendPQExpBuffer(details, ",\n    NEGATOR = %s", name);

    if (strcmp(oprcanmerge, "t") == 0)
        appendPQExpBuffer(details, ",\n    MERGES");

    if (strcmp(oprcanhash, "t") == 0)
        appendPQExpBuffer(details, ",\n    HASHES");

    name = convertRegProcReference(fout, oprrest);
    if (name)
        appendPQExpBuffer(details, ",\n    RESTRICT = %s", name);

    name = convertRegProcReference(fout, oprjoin);
    if (name)
        appendPQExpBuffer(details, ",\n    JOIN = %s", name);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP OPERATOR %s.%s;\n",
                      fmtId(oprinfo->dobj.namespace->dobj.name),
                      oprid->data);

    appendPQExpBuffer(q, "CREATE OPERATOR %s (\n%s\n);\n",
                      oprinfo->dobj.name, details->data);

    appendPQExpBuffer(labelq, "OPERATOR %s", oprid->data);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &oprinfo->dobj, labelq->data);

    ArchiveEntry(fout, oprinfo->dobj.catId, oprinfo->dobj.dumpId,
                 oprinfo->dobj.name,
                 oprinfo->dobj.namespace->dobj.name,
                 NULL,
                 oprinfo->rolname,
                 false, "OPERATOR", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Operator Comments */
    dumpComment(fout, labelq->data,
                oprinfo->dobj.namespace->dobj.name, oprinfo->rolname,
                oprinfo->dobj.catId, 0, oprinfo->dobj.dumpId);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(oprid);
    destroyPQExpBuffer(details);
}

static void dumpProcLang ( Archive fout,
ProcLangInfo plang 
) [static]

Definition at line 9195 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _funcInfo::dobj, _procLangInfo::dobj, _dumpableObject::dump, dumpACL(), dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), _dumpableObject::ext_member, findFuncByOid(), fmtId(), free, _procLangInfo::lanacl, _procLangInfo::laninline, _procLangInfo::lanowner, _procLangInfo::lanplcallfoid, _procLangInfo::lanpltrusted, _procLangInfo::lanvalidator, _dumpableObject::name, NULL, OidIsValid, pg_strdup(), SECTION_PRE_DATA, and shouldDumpProcLangs().

Referenced by dumpDumpableObject().

{
    PQExpBuffer defqry;
    PQExpBuffer delqry;
    PQExpBuffer labelq;
    bool        useParams;
    char       *qlanname;
    char       *lanschema;
    FuncInfo   *funcInfo;
    FuncInfo   *inlineInfo = NULL;
    FuncInfo   *validatorInfo = NULL;

    /* Skip if not to be dumped */
    if (!plang->dobj.dump || dataOnly)
        return;

    /*
     * Try to find the support function(s).  It is not an error if we don't
     * find them --- if the functions are in the pg_catalog schema, as is
     * standard in 8.1 and up, then we won't have loaded them. (In this case
     * we will emit a parameterless CREATE LANGUAGE command, which will
     * require PL template knowledge in the backend to reload.)
     */

    funcInfo = findFuncByOid(plang->lanplcallfoid);
    if (funcInfo != NULL && !funcInfo->dobj.dump)
        funcInfo = NULL;        /* treat not-dumped same as not-found */

    if (OidIsValid(plang->laninline))
    {
        inlineInfo = findFuncByOid(plang->laninline);
        if (inlineInfo != NULL && !inlineInfo->dobj.dump)
            inlineInfo = NULL;
    }

    if (OidIsValid(plang->lanvalidator))
    {
        validatorInfo = findFuncByOid(plang->lanvalidator);
        if (validatorInfo != NULL && !validatorInfo->dobj.dump)
            validatorInfo = NULL;
    }

    /*
     * If the functions are dumpable then emit a traditional CREATE LANGUAGE
     * with parameters.  Otherwise, dump only if shouldDumpProcLangs() says to
     * dump it.
     *
     * However, for a language that belongs to an extension, we must not use
     * the shouldDumpProcLangs heuristic, but just dump the language iff we're
     * told to (via dobj.dump).  Generally the support functions will belong
     * to the same extension and so have the same dump flags ... if they
     * don't, this might not work terribly nicely.
     */
    useParams = (funcInfo != NULL &&
                 (inlineInfo != NULL || !OidIsValid(plang->laninline)) &&
                 (validatorInfo != NULL || !OidIsValid(plang->lanvalidator)));

    if (!plang->dobj.ext_member)
    {
        if (!useParams && !shouldDumpProcLangs())
            return;
    }

    defqry = createPQExpBuffer();
    delqry = createPQExpBuffer();
    labelq = createPQExpBuffer();

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

    /*
     * If dumping a HANDLER clause, treat the language as being in the handler
     * function's schema; this avoids cluttering the HANDLER clause. Otherwise
     * it doesn't really have a schema.
     */
    if (useParams)
        lanschema = funcInfo->dobj.namespace->dobj.name;
    else
        lanschema = NULL;

    appendPQExpBuffer(delqry, "DROP PROCEDURAL LANGUAGE %s;\n",
                      qlanname);

    if (useParams)
    {
        appendPQExpBuffer(defqry, "CREATE %sPROCEDURAL LANGUAGE %s",
                          plang->lanpltrusted ? "TRUSTED " : "",
                          qlanname);
        appendPQExpBuffer(defqry, " HANDLER %s",
                          fmtId(funcInfo->dobj.name));
        if (OidIsValid(plang->laninline))
        {
            appendPQExpBuffer(defqry, " INLINE ");
            /* Cope with possibility that inline is in different schema */
            if (inlineInfo->dobj.namespace != funcInfo->dobj.namespace)
                appendPQExpBuffer(defqry, "%s.",
                               fmtId(inlineInfo->dobj.namespace->dobj.name));
            appendPQExpBuffer(defqry, "%s",
                              fmtId(inlineInfo->dobj.name));
        }
        if (OidIsValid(plang->lanvalidator))
        {
            appendPQExpBuffer(defqry, " VALIDATOR ");
            /* Cope with possibility that validator is in different schema */
            if (validatorInfo->dobj.namespace != funcInfo->dobj.namespace)
                appendPQExpBuffer(defqry, "%s.",
                            fmtId(validatorInfo->dobj.namespace->dobj.name));
            appendPQExpBuffer(defqry, "%s",
                              fmtId(validatorInfo->dobj.name));
        }
    }
    else
    {
        /*
         * If not dumping parameters, then use CREATE OR REPLACE so that the
         * command will not fail if the language is preinstalled in the target
         * database.  We restrict the use of REPLACE to this case so as to
         * eliminate the risk of replacing a language with incompatible
         * parameter settings: this command will only succeed at all if there
         * is a pg_pltemplate entry, and if there is one, the existing entry
         * must match it too.
         */
        appendPQExpBuffer(defqry, "CREATE OR REPLACE PROCEDURAL LANGUAGE %s",
                          qlanname);
    }
    appendPQExpBuffer(defqry, ";\n");

    appendPQExpBuffer(labelq, "LANGUAGE %s", qlanname);

    if (binary_upgrade)
        binary_upgrade_extension_member(defqry, &plang->dobj, labelq->data);

    ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
                 plang->dobj.name,
                 lanschema, NULL, plang->lanowner,
                 false, "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
                 defqry->data, delqry->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Proc Lang Comments and Security Labels */
    dumpComment(fout, labelq->data,
                NULL, "",
                plang->dobj.catId, 0, plang->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 NULL, "",
                 plang->dobj.catId, 0, plang->dobj.dumpId);

    if (plang->lanpltrusted)
        dumpACL(fout, plang->dobj.catId, plang->dobj.dumpId, "LANGUAGE",
                qlanname, NULL, plang->dobj.name,
                lanschema,
                plang->lanowner, plang->lanacl);

    free(qlanname);

    destroyPQExpBuffer(defqry);
    destroyPQExpBuffer(delqry);
    destroyPQExpBuffer(labelq);
}

static void dumpRangeType ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 8107 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), atooid, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_type_oids_by_type_oid(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _collInfo::dobj, dumpACL(), dumpComment(), dumpSecLabel(), ExecuteSqlQueryForSingleRow(), findCollationByOid(), fmtId(), _dumpableObject::name, NULL, OidIsValid, pg_strdup(), PQclear(), PQfnumber(), PQgetvalue(), SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpType().

{
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    Oid         collationOid;
    char       *qtypname;
    char       *procname;

    /*
     * select appropriate schema to ensure names in CREATE are properly
     * qualified
     */
    selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);

    appendPQExpBuffer(query,
            "SELECT pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
                      "opc.opcname AS opcname, "
                      "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
                      "  WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
                      "opc.opcdefault, "
                      "CASE WHEN rngcollation = st.typcollation THEN 0 "
                      "     ELSE rngcollation END AS collation, "
                      "rngcanonical, rngsubdiff "
                      "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
                      "     pg_catalog.pg_opclass opc "
                      "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
                      "rngtypid = '%u'",
                      tyinfo->dobj.catId.oid);

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

    qtypname = pg_strdup(fmtId(tyinfo->dobj.name));

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog.
     * CASCADE shouldn't be required here as for normal types since the I/O
     * functions are generic and do not get dropped.
     */
    appendPQExpBuffer(delq, "DROP TYPE %s.",
                      fmtId(tyinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, "%s;\n",
                      qtypname);

    if (binary_upgrade)
        binary_upgrade_set_type_oids_by_type_oid(fout,
                                                 q, tyinfo->dobj.catId.oid);

    appendPQExpBuffer(q, "CREATE TYPE %s AS RANGE (",
                      qtypname);

    appendPQExpBuffer(q, "\n    subtype = %s",
                      PQgetvalue(res, 0, PQfnumber(res, "rngsubtype")));

    /* print subtype_opclass only if not default for subtype */
    if (PQgetvalue(res, 0, PQfnumber(res, "opcdefault"))[0] != 't')
    {
        char       *opcname = PQgetvalue(res, 0, PQfnumber(res, "opcname"));
        char       *nspname = PQgetvalue(res, 0, PQfnumber(res, "opcnsp"));

        /* always schema-qualify, don't try to be smart */
        appendPQExpBuffer(q, ",\n    subtype_opclass = %s.",
                          fmtId(nspname));
        appendPQExpBuffer(q, "%s", fmtId(opcname));
    }

    collationOid = atooid(PQgetvalue(res, 0, PQfnumber(res, "collation")));
    if (OidIsValid(collationOid))
    {
        CollInfo   *coll = findCollationByOid(collationOid);

        if (coll)
        {
            /* always schema-qualify, don't try to be smart */
            appendPQExpBuffer(q, ",\n    collation = %s.",
                              fmtId(coll->dobj.namespace->dobj.name));
            appendPQExpBuffer(q, "%s",
                              fmtId(coll->dobj.name));
        }
    }

    procname = PQgetvalue(res, 0, PQfnumber(res, "rngcanonical"));
    if (strcmp(procname, "-") != 0)
        appendPQExpBuffer(q, ",\n    canonical = %s", procname);

    procname = PQgetvalue(res, 0, PQfnumber(res, "rngsubdiff"));
    if (strcmp(procname, "-") != 0)
        appendPQExpBuffer(q, ",\n    subtype_diff = %s", procname);

    appendPQExpBuffer(q, "\n);\n");

    appendPQExpBuffer(labelq, "TYPE %s", qtypname);

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);

    ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
                 tyinfo->dobj.name,
                 tyinfo->dobj.namespace->dobj.name,
                 NULL,
                 tyinfo->rolname, false,
                 "TYPE", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Type Comments and Security Labels */
    dumpComment(fout, labelq->data,
                tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
                 tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);

    dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
            qtypname, NULL, tyinfo->dobj.name,
            tyinfo->dobj.namespace->dobj.name,
            tyinfo->rolname, tyinfo->typacl);

    PQclear(res);
    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);
}

static void dumpRule ( Archive fout,
RuleInfo rinfo 
) [static]

Definition at line 14367 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _ruleInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, _ruleInfo::ev_enabled, ExecuteSqlQuery(), exit_nicely, fmtId(), _dumpableObject::name, NULL, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), printfPQExpBuffer(), _ruleInfo::reloptions, Archive::remoteVersion, _tableInfo::rolname, _ruleInfo::ruletable, SECTION_POST_DATA, selectSourceSchema(), _ruleInfo::separate, and write_msg().

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = rinfo->ruletable;
    PQExpBuffer query;
    PQExpBuffer cmd;
    PQExpBuffer delcmd;
    PQExpBuffer labelq;
    PGresult   *res;

    /* Skip if not to be dumped */
    if (!rinfo->dobj.dump || dataOnly)
        return;

    /*
     * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
     * we do not want to dump it as a separate object.
     */
    if (!rinfo->separate)
        return;

    /*
     * Make sure we are in proper schema.
     */
    selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

    query = createPQExpBuffer();
    cmd = createPQExpBuffer();
    delcmd = createPQExpBuffer();
    labelq = createPQExpBuffer();

    if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query,
                          "SELECT pg_catalog.pg_get_ruledef('%u'::pg_catalog.oid) AS definition",
                          rinfo->dobj.catId.oid);
    }
    else
    {
        /* Rule name was unique before 7.3 ... */
        appendPQExpBuffer(query,
                          "SELECT pg_get_ruledef('%s') AS definition",
                          rinfo->dobj.name);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    if (PQntuples(res) != 1)
    {
        write_msg(NULL, "query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned\n",
                  rinfo->dobj.name, tbinfo->dobj.name);
        exit_nicely(1);
    }

    printfPQExpBuffer(cmd, "%s\n", PQgetvalue(res, 0, 0));

    /*
     * Add the command to alter the rules replication firing semantics if it
     * differs from the default.
     */
    if (rinfo->ev_enabled != 'O')
    {
        appendPQExpBuffer(cmd, "ALTER TABLE %s ", fmtId(tbinfo->dobj.name));
        switch (rinfo->ev_enabled)
        {
            case 'A':
                appendPQExpBuffer(cmd, "ENABLE ALWAYS RULE %s;\n",
                                  fmtId(rinfo->dobj.name));
                break;
            case 'R':
                appendPQExpBuffer(cmd, "ENABLE REPLICA RULE %s;\n",
                                  fmtId(rinfo->dobj.name));
                break;
            case 'D':
                appendPQExpBuffer(cmd, "DISABLE RULE %s;\n",
                                  fmtId(rinfo->dobj.name));
                break;
        }
    }

    /*
     * Apply view's reloptions when its ON SELECT rule is separate.
     */
    if (rinfo->reloptions && strlen(rinfo->reloptions) > 0)
    {
        appendPQExpBuffer(cmd, "ALTER VIEW %s SET (%s);\n",
                          fmtId(tbinfo->dobj.name),
                          rinfo->reloptions);
    }

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delcmd, "DROP RULE %s ",
                      fmtId(rinfo->dobj.name));
    appendPQExpBuffer(delcmd, "ON %s.",
                      fmtId(tbinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delcmd, "%s;\n",
                      fmtId(tbinfo->dobj.name));

    appendPQExpBuffer(labelq, "RULE %s",
                      fmtId(rinfo->dobj.name));
    appendPQExpBuffer(labelq, " ON %s",
                      fmtId(tbinfo->dobj.name));

    ArchiveEntry(fout, rinfo->dobj.catId, rinfo->dobj.dumpId,
                 rinfo->dobj.name,
                 tbinfo->dobj.namespace->dobj.name,
                 NULL,
                 tbinfo->rolname, false,
                 "RULE", SECTION_POST_DATA,
                 cmd->data, delcmd->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump rule comments */
    dumpComment(fout, labelq->data,
                tbinfo->dobj.namespace->dobj.name,
                tbinfo->rolname,
                rinfo->dobj.catId, 0, rinfo->dobj.dumpId);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(cmd);
    destroyPQExpBuffer(delcmd);
    destroyPQExpBuffer(labelq);
}

static void dumpSecLabel ( Archive fout,
const char *  target,
const char *  namespace,
const char *  owner,
CatalogId  catalogId,
int  subid,
DumpId  dumpId 
) [static]

Definition at line 12379 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), findSecLabels(), fmtId(), i, label, PQExpBufferData::len, no_security_labels, NULL, CatalogId::oid, schemaOnly, SECTION_NONE, and CatalogId::tableoid.

Referenced by dumpAgg(), dumpBaseType(), dumpBlob(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpExtension(), dumpFunc(), dumpNamespace(), dumpProcLang(), dumpRangeType(), and dumpSequence().

{
    SecLabelItem *labels;
    int         nlabels;
    int         i;
    PQExpBuffer query;

    /* do nothing, if --no-security-labels is supplied */
    if (no_security_labels)
        return;

    /* Comments are schema not data ... except blob comments are data */
    if (strncmp(target, "LARGE OBJECT ", 13) != 0)
    {
        if (dataOnly)
            return;
    }
    else
    {
        if (schemaOnly)
            return;
    }

    /* Search for security labels associated with catalogId, using table */
    nlabels = findSecLabels(fout, catalogId.tableoid, catalogId.oid, &labels);

    query = createPQExpBuffer();

    for (i = 0; i < nlabels; i++)
    {
        /*
         * Ignore label entries for which the subid doesn't match.
         */
        if (labels[i].objsubid != subid)
            continue;

        appendPQExpBuffer(query,
                          "SECURITY LABEL FOR %s ON %s IS ",
                          fmtId(labels[i].provider), target);
        appendStringLiteralAH(query, labels[i].label, fout);
        appendPQExpBuffer(query, ";\n");
    }

    if (query->len > 0)
    {
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     target, namespace, NULL, owner,
                     false, "SECURITY LABEL", SECTION_NONE,
                     query->data, "", NULL,
                     &(dumpId), 1,
                     NULL, NULL);
    }
    destroyPQExpBuffer(query);
}

static void dumpSequence ( Archive fout,
TableInfo tbinfo 
) [static]

Definition at line 13842 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), _tableInfo::attnames, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_rel_oid(), _dumpableObject::catId, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, dumpSecLabel(), ExecuteSqlQuery(), exit_nicely, findTableByOid(), fmtId(), _dumpableObject::name, ngettext, NULL, CatalogId::oid, OidIsValid, _tableInfo::owning_col, _tableInfo::owning_tab, PGRES_TUPLES_OK, PQclear(), PQgetisnull(), PQgetvalue(), PQntuples(), Archive::remoteVersion, resetPQExpBuffer(), _tableInfo::rolname, SECTION_PRE_DATA, selectSourceSchema(), SEQ_MAXVALUE, SEQ_MINVALUE, snprintf(), and write_msg().

Referenced by dumpTable().

{
    PGresult   *res;
    char       *startv,
               *incby,
               *maxv = NULL,
               *minv = NULL,
               *cache;
    char        bufm[100],
                bufx[100];
    bool        cycled;
    PQExpBuffer query = createPQExpBuffer();
    PQExpBuffer delqry = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

    snprintf(bufm, sizeof(bufm), INT64_FORMAT, SEQ_MINVALUE);
    snprintf(bufx, sizeof(bufx), INT64_FORMAT, SEQ_MAXVALUE);

    if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query,
                          "SELECT sequence_name, "
                          "start_value, increment_by, "
                   "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
                   "     WHEN increment_by < 0 AND max_value = -1 THEN NULL "
                          "     ELSE max_value "
                          "END AS max_value, "
                    "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
                   "     WHEN increment_by < 0 AND min_value = %s THEN NULL "
                          "     ELSE min_value "
                          "END AS min_value, "
                          "cache_value, is_cycled FROM %s",
                          bufx, bufm,
                          fmtId(tbinfo->dobj.name));
    }
    else
    {
        appendPQExpBuffer(query,
                          "SELECT sequence_name, "
                          "0 AS start_value, increment_by, "
                   "CASE WHEN increment_by > 0 AND max_value = %s THEN NULL "
                   "     WHEN increment_by < 0 AND max_value = -1 THEN NULL "
                          "     ELSE max_value "
                          "END AS max_value, "
                    "CASE WHEN increment_by > 0 AND min_value = 1 THEN NULL "
                   "     WHEN increment_by < 0 AND min_value = %s THEN NULL "
                          "     ELSE min_value "
                          "END AS min_value, "
                          "cache_value, is_cycled FROM %s",
                          bufx, bufm,
                          fmtId(tbinfo->dobj.name));
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    if (PQntuples(res) != 1)
    {
        write_msg(NULL, ngettext("query to get data of sequence \"%s\" returned %d row (expected 1)\n",
                                 "query to get data of sequence \"%s\" returned %d rows (expected 1)\n",
                                 PQntuples(res)),
                  tbinfo->dobj.name, PQntuples(res));
        exit_nicely(1);
    }

    /* Disable this check: it fails if sequence has been renamed */
#ifdef NOT_USED
    if (strcmp(PQgetvalue(res, 0, 0), tbinfo->dobj.name) != 0)
    {
        write_msg(NULL, "query to get data of sequence \"%s\" returned name \"%s\"\n",
                  tbinfo->dobj.name, PQgetvalue(res, 0, 0));
        exit_nicely(1);
    }
#endif

    startv = PQgetvalue(res, 0, 1);
    incby = PQgetvalue(res, 0, 2);
    if (!PQgetisnull(res, 0, 3))
        maxv = PQgetvalue(res, 0, 3);
    if (!PQgetisnull(res, 0, 4))
        minv = PQgetvalue(res, 0, 4);
    cache = PQgetvalue(res, 0, 5);
    cycled = (strcmp(PQgetvalue(res, 0, 6), "t") == 0);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delqry, "DROP SEQUENCE %s.",
                      fmtId(tbinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delqry, "%s;\n",
                      fmtId(tbinfo->dobj.name));

    resetPQExpBuffer(query);

    if (binary_upgrade)
    {
        binary_upgrade_set_pg_class_oids(fout, query,
                                         tbinfo->dobj.catId.oid, false);
        binary_upgrade_set_type_oids_by_rel_oid(fout, query,
                                                tbinfo->dobj.catId.oid);
    }

    appendPQExpBuffer(query,
                      "CREATE SEQUENCE %s\n",
                      fmtId(tbinfo->dobj.name));

    if (fout->remoteVersion >= 80400)
        appendPQExpBuffer(query, "    START WITH %s\n", startv);

    appendPQExpBuffer(query, "    INCREMENT BY %s\n", incby);

    if (minv)
        appendPQExpBuffer(query, "    MINVALUE %s\n", minv);
    else
        appendPQExpBuffer(query, "    NO MINVALUE\n");

    if (maxv)
        appendPQExpBuffer(query, "    MAXVALUE %s\n", maxv);
    else
        appendPQExpBuffer(query, "    NO MAXVALUE\n");

    appendPQExpBuffer(query,
                      "    CACHE %s%s",
                      cache, (cycled ? "\n    CYCLE" : ""));

    appendPQExpBuffer(query, ";\n");

    appendPQExpBuffer(labelq, "SEQUENCE %s", fmtId(tbinfo->dobj.name));

    /* binary_upgrade:  no need to clear TOAST table oid */

    if (binary_upgrade)
        binary_upgrade_extension_member(query, &tbinfo->dobj,
                                        labelq->data);

    ArchiveEntry(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
                 tbinfo->dobj.name,
                 tbinfo->dobj.namespace->dobj.name,
                 NULL,
                 tbinfo->rolname,
                 false, "SEQUENCE", SECTION_PRE_DATA,
                 query->data, delqry->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /*
     * If the sequence is owned by a table column, emit the ALTER for it as a
     * separate TOC entry immediately following the sequence's own entry. It's
     * OK to do this rather than using full sorting logic, because the
     * dependency that tells us it's owned will have forced the table to be
     * created first.  We can't just include the ALTER in the TOC entry
     * because it will fail if we haven't reassigned the sequence owner to
     * match the table's owner.
     *
     * We need not schema-qualify the table reference because both sequence
     * and table must be in the same schema.
     */
    if (OidIsValid(tbinfo->owning_tab))
    {
        TableInfo  *owning_tab = findTableByOid(tbinfo->owning_tab);

        if (owning_tab && owning_tab->dobj.dump)
        {
            resetPQExpBuffer(query);
            appendPQExpBuffer(query, "ALTER SEQUENCE %s",
                              fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(query, " OWNED BY %s",
                              fmtId(owning_tab->dobj.name));
            appendPQExpBuffer(query, ".%s;\n",
                        fmtId(owning_tab->attnames[tbinfo->owning_col - 1]));

            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         tbinfo->dobj.name,
                         tbinfo->dobj.namespace->dobj.name,
                         NULL,
                         tbinfo->rolname,
                         false, "SEQUENCE OWNED BY", SECTION_PRE_DATA,
                         query->data, "", NULL,
                         &(tbinfo->dobj.dumpId), 1,
                         NULL, NULL);
        }
    }

    /* Dump Sequence Comments and Security Labels */
    dumpComment(fout, labelq->data,
                tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
                tbinfo->dobj.catId, 0, tbinfo->dobj.dumpId);
    dumpSecLabel(fout, labelq->data,
                 tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
                 tbinfo->dobj.catId, 0, tbinfo->dobj.dumpId);

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(delqry);
    destroyPQExpBuffer(labelq);
}

static void dumpSequenceData ( Archive fout,
TableDataInfo tdinfo 
) [static]

Definition at line 14047 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dumpId, ExecuteSqlQuery(), exit_nicely, fmtId(), _dumpableObject::name, ngettext, NULL, PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), resetPQExpBuffer(), _tableInfo::rolname, SECTION_DATA, selectSourceSchema(), _tableDataInfo::tdtable, and write_msg().

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = tdinfo->tdtable;
    PGresult   *res;
    char       *last;
    bool        called;
    PQExpBuffer query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

    appendPQExpBuffer(query,
                      "SELECT last_value, is_called FROM %s",
                      fmtId(tbinfo->dobj.name));

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    if (PQntuples(res) != 1)
    {
        write_msg(NULL, ngettext("query to get data of sequence \"%s\" returned %d row (expected 1)\n",
                                 "query to get data of sequence \"%s\" returned %d rows (expected 1)\n",
                                 PQntuples(res)),
                  tbinfo->dobj.name, PQntuples(res));
        exit_nicely(1);
    }

    last = PQgetvalue(res, 0, 0);
    called = (strcmp(PQgetvalue(res, 0, 1), "t") == 0);

    resetPQExpBuffer(query);
    appendPQExpBuffer(query, "SELECT pg_catalog.setval(");
    appendStringLiteralAH(query, fmtId(tbinfo->dobj.name), fout);
    appendPQExpBuffer(query, ", %s, %s);\n",
                      last, (called ? "true" : "false"));

    ArchiveEntry(fout, nilCatalogId, createDumpId(),
                 tbinfo->dobj.name,
                 tbinfo->dobj.namespace->dobj.name,
                 NULL,
                 tbinfo->rolname,
                 false, "SEQUENCE SET", SECTION_DATA,
                 query->data, "", NULL,
                 &(tbinfo->dobj.dumpId), 1,
                 NULL, NULL);

    PQclear(res);

    destroyPQExpBuffer(query);
}

static void dumpShellType ( Archive fout,
ShellTypeInfo stinfo 
) [static]

Definition at line 9124 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), _shellTypeInfo::baseType, binary_upgrade, binary_upgrade_set_type_oids_by_type_oid(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _shellTypeInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, fmtId(), _dumpableObject::name, NULL, and SECTION_PRE_DATA.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;

    /* Skip if not to be dumped */
    if (!stinfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();

    /*
     * Note the lack of a DROP command for the shell type; any required DROP
     * is driven off the base type entry, instead.  This interacts with
     * _printTocEntry()'s use of the presence of a DROP command to decide
     * whether an entry needs an ALTER OWNER command.  We don't want to alter
     * the shell type's owner immediately on creation; that should happen only
     * after it's filled in, otherwise the backend complains.
     */

    if (binary_upgrade)
        binary_upgrade_set_type_oids_by_type_oid(fout, q,
                                           stinfo->baseType->dobj.catId.oid);

    appendPQExpBuffer(q, "CREATE TYPE %s;\n",
                      fmtId(stinfo->dobj.name));

    ArchiveEntry(fout, stinfo->dobj.catId, stinfo->dobj.dumpId,
                 stinfo->dobj.name,
                 stinfo->dobj.namespace->dobj.name,
                 NULL,
                 stinfo->baseType->rolname, false,
                 "SHELL TYPE", SECTION_PRE_DATA,
                 q->data, "", NULL,
                 NULL, 0,
                 NULL, NULL);

    destroyPQExpBuffer(q);
}

static void dumpStdStrings ( Archive AH  )  [static]

Definition at line 2453 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), g_verbose, NULL, SECTION_PRE_DATA, Archive::std_strings, and write_msg().

Referenced by main().

{
    const char *stdstrings = AH->std_strings ? "on" : "off";
    PQExpBuffer qry = createPQExpBuffer();

    if (g_verbose)
        write_msg(NULL, "saving standard_conforming_strings = %s\n",
                  stdstrings);

    appendPQExpBuffer(qry, "SET standard_conforming_strings = '%s';\n",
                      stdstrings);

    ArchiveEntry(AH, nilCatalogId, createDumpId(),
                 "STDSTRINGS", NULL, NULL, "",
                 false, "STDSTRINGS", SECTION_PRE_DATA,
                 qry->data, "", NULL,
                 NULL, 0,
                 NULL, NULL);

    destroyPQExpBuffer(qry);
}

static void dumpTable ( Archive fout,
TableInfo tbinfo 
) [static]

Definition at line 12664 of file pg_dump.c.

References appendPQExpBuffer(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dump, dumpACL(), _dumpableObject::dumpId, dumpSequence(), dumpTableSchema(), ExecuteSqlQuery(), fmtId(), free, i, _dumpableObject::name, NULL, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), _tableInfo::relacl, _tableInfo::relkind, RELKIND_SEQUENCE, Archive::remoteVersion, and _tableInfo::rolname.

Referenced by dumpDumpableObject().

{
    if (tbinfo->dobj.dump && !dataOnly)
    {
        char       *namecopy;

        if (tbinfo->relkind == RELKIND_SEQUENCE)
            dumpSequence(fout, tbinfo);
        else
            dumpTableSchema(fout, tbinfo);

        /* Handle the ACL here */
        namecopy = pg_strdup(fmtId(tbinfo->dobj.name));
        dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
                (tbinfo->relkind == RELKIND_SEQUENCE) ? "SEQUENCE" :
                "TABLE",
                namecopy, NULL, tbinfo->dobj.name,
                tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
                tbinfo->relacl);

        /*
         * Handle column ACLs, if any.  Note: we pull these with a separate
         * query rather than trying to fetch them during getTableAttrs, so
         * that we won't miss ACLs on system columns.
         */
        if (fout->remoteVersion >= 80400)
        {
            PQExpBuffer query = createPQExpBuffer();
            PGresult   *res;
            int         i;

            appendPQExpBuffer(query,
                       "SELECT attname, attacl FROM pg_catalog.pg_attribute "
                              "WHERE attrelid = '%u' AND NOT attisdropped AND attacl IS NOT NULL "
                              "ORDER BY attnum",
                              tbinfo->dobj.catId.oid);
            res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

            for (i = 0; i < PQntuples(res); i++)
            {
                char       *attname = PQgetvalue(res, i, 0);
                char       *attacl = PQgetvalue(res, i, 1);
                char       *attnamecopy;
                char       *acltag;

                attnamecopy = pg_strdup(fmtId(attname));
                acltag = pg_malloc(strlen(tbinfo->dobj.name) + strlen(attname) + 2);
                sprintf(acltag, "%s.%s", tbinfo->dobj.name, attname);
                /* Column's GRANT type is always TABLE */
                dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId, "TABLE",
                        namecopy, attnamecopy, acltag,
                        tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
                        attacl);
                free(attnamecopy);
                free(acltag);
            }
            PQclear(res);
            destroyPQExpBuffer(query);
        }

        free(namecopy);
    }
}

static void dumpTableComment ( Archive fout,
TableInfo tbinfo,
const char *  reltypename 
) [static]

Definition at line 7386 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), _tableInfo::attnames, _dumpableObject::catId, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, CommentItem::descr, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dumpId, findComments(), fmtId(), _dumpableObject::name, NULL, CommentItem::objsubid, CatalogId::oid, resetPQExpBuffer(), _tableInfo::rolname, SECTION_NONE, and CatalogId::tableoid.

Referenced by dumpTableSchema().

{
    CommentItem *comments;
    int         ncomments;
    PQExpBuffer query;
    PQExpBuffer target;

    /* Comments are SCHEMA not data */
    if (dataOnly)
        return;

    /* Search for comments associated with relation, using table */
    ncomments = findComments(fout,
                             tbinfo->dobj.catId.tableoid,
                             tbinfo->dobj.catId.oid,
                             &comments);

    /* If comments exist, build COMMENT ON statements */
    if (ncomments <= 0)
        return;

    query = createPQExpBuffer();
    target = createPQExpBuffer();

    while (ncomments > 0)
    {
        const char *descr = comments->descr;
        int         objsubid = comments->objsubid;

        if (objsubid == 0)
        {
            resetPQExpBuffer(target);
            appendPQExpBuffer(target, "%s %s", reltypename,
                              fmtId(tbinfo->dobj.name));

            resetPQExpBuffer(query);
            appendPQExpBuffer(query, "COMMENT ON %s IS ", target->data);
            appendStringLiteralAH(query, descr, fout);
            appendPQExpBuffer(query, ";\n");

            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         target->data,
                         tbinfo->dobj.namespace->dobj.name,
                         NULL, tbinfo->rolname,
                         false, "COMMENT", SECTION_NONE,
                         query->data, "", NULL,
                         &(tbinfo->dobj.dumpId), 1,
                         NULL, NULL);
        }
        else if (objsubid > 0 && objsubid <= tbinfo->numatts)
        {
            resetPQExpBuffer(target);
            appendPQExpBuffer(target, "COLUMN %s.",
                              fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(target, "%s",
                              fmtId(tbinfo->attnames[objsubid - 1]));

            resetPQExpBuffer(query);
            appendPQExpBuffer(query, "COMMENT ON %s IS ", target->data);
            appendStringLiteralAH(query, descr, fout);
            appendPQExpBuffer(query, ";\n");

            ArchiveEntry(fout, nilCatalogId, createDumpId(),
                         target->data,
                         tbinfo->dobj.namespace->dobj.name,
                         NULL, tbinfo->rolname,
                         false, "COMMENT", SECTION_NONE,
                         query->data, "", NULL,
                         &(tbinfo->dobj.dumpId), 1,
                         NULL, NULL);
        }

        comments++;
        ncomments--;
    }

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(target);
}

static void dumpTableConstraintComment ( Archive fout,
ConstraintInfo coninfo 
) [static]
static void dumpTableData ( Archive fout,
TableDataInfo tdinfo 
) [static]

Definition at line 1704 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableDataInfo::dobj, _tableInfo::dobj, dump_inserts, _dumpableObject::dumpId, fmtCopyColumnList(), fmtId(), _tableInfo::hasoids, _dumpableObject::name, NULL, _tableDataInfo::oids, _tableInfo::rolname, SECTION_DATA, and _tableDataInfo::tdtable.

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = tdinfo->tdtable;
    PQExpBuffer copyBuf = createPQExpBuffer();
    PQExpBuffer clistBuf = createPQExpBuffer();
    DataDumperPtr dumpFn;
    char       *copyStmt;

    if (!dump_inserts)
    {
        /* Dump/restore using COPY */
        dumpFn = dumpTableData_copy;
        /* must use 2 steps here 'cause fmtId is nonreentrant */
        appendPQExpBuffer(copyBuf, "COPY %s ",
                          fmtId(tbinfo->dobj.name));
        appendPQExpBuffer(copyBuf, "%s %sFROM stdin;\n",
                          fmtCopyColumnList(tbinfo, clistBuf),
                      (tdinfo->oids && tbinfo->hasoids) ? "WITH OIDS " : "");
        copyStmt = copyBuf->data;
    }
    else
    {
        /* Restore using INSERT */
        dumpFn = dumpTableData_insert;
        copyStmt = NULL;
    }

    /*
     * Note: although the TableDataInfo is a full DumpableObject, we treat its
     * dependency on its table as "special" and pass it to ArchiveEntry now.
     * See comments for BuildArchiveDependencies.
     */
    ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
                 tbinfo->dobj.name, tbinfo->dobj.namespace->dobj.name,
                 NULL, tbinfo->rolname,
                 false, "TABLE DATA", SECTION_DATA,
                 "", "", copyStmt,
                 &(tbinfo->dobj.dumpId), 1,
                 dumpFn, tdinfo);

    destroyPQExpBuffer(copyBuf);
    destroyPQExpBuffer(clistBuf);
}

static int dumpTableData_copy ( Archive fout,
void *  dcontext 
) [static]

Definition at line 1371 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), archprintf(), conn, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, ExecuteSqlQuery(), exit_nicely, _tableDataInfo::filtercond, fmtCopyColumnList(), fmtQualifiedId(), g_verbose, GetConnection(), _tableInfo::hasoids, PQExpBufferData::len, _dumpableObject::name, NULL, _tableDataInfo::oids, PGRES_COMMAND_OK, PGRES_COPY_OUT, PQclear(), PQerrorMessage(), PQfreemem(), PQgetCopyData(), PQgetResult(), PQresultStatus(), Archive::remoteVersion, selectSourceSchema(), _tableDataInfo::tdtable, write_msg(), and WriteData().

{
    TableDataInfo *tdinfo = (TableDataInfo *) dcontext;
    TableInfo  *tbinfo = tdinfo->tdtable;
    const char *classname = tbinfo->dobj.name;
    const bool  hasoids = tbinfo->hasoids;
    const bool  oids = tdinfo->oids;
    PQExpBuffer q = createPQExpBuffer();

    /*
     * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
     * which uses it already.
     */
    PQExpBuffer clistBuf = createPQExpBuffer();
    PGconn     *conn = GetConnection(fout);
    PGresult   *res;
    int         ret;
    char       *copybuf;
    const char *column_list;

    if (g_verbose)
        write_msg(NULL, "dumping contents of table %s\n", classname);

    /*
     * Make sure we are in proper schema.  We will qualify the table name
     * below anyway (in case its name conflicts with a pg_catalog table); but
     * this ensures reproducible results in case the table contains regproc,
     * regclass, etc columns.
     */
    selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

    /*
     * If possible, specify the column list explicitly so that we have no
     * possibility of retrieving data in the wrong column order.  (The default
     * column ordering of COPY will not be what we want in certain corner
     * cases involving ADD COLUMN and inheritance.)
     */
    if (fout->remoteVersion >= 70300)
        column_list = fmtCopyColumnList(tbinfo, clistBuf);
    else
        column_list = "";       /* can't select columns in COPY */

    if (oids && hasoids)
    {
        appendPQExpBuffer(q, "COPY %s %s WITH OIDS TO stdout;",
                          fmtQualifiedId(fout->remoteVersion,
                                         tbinfo->dobj.namespace->dobj.name,
                                         classname),
                          column_list);
    }
    else if (tdinfo->filtercond)
    {
        /* Note: this syntax is only supported in 8.2 and up */
        appendPQExpBufferStr(q, "COPY (SELECT ");
        /* klugery to get rid of parens in column list */
        if (strlen(column_list) > 2)
        {
            appendPQExpBufferStr(q, column_list + 1);
            q->data[q->len - 1] = ' ';
        }
        else
            appendPQExpBufferStr(q, "* ");
        appendPQExpBuffer(q, "FROM %s %s) TO stdout;",
                          fmtQualifiedId(fout->remoteVersion,
                                         tbinfo->dobj.namespace->dobj.name,
                                         classname),
                          tdinfo->filtercond);
    }
    else
    {
        appendPQExpBuffer(q, "COPY %s %s TO stdout;",
                          fmtQualifiedId(fout->remoteVersion,
                                         tbinfo->dobj.namespace->dobj.name,
                                         classname),
                          column_list);
    }
    res = ExecuteSqlQuery(fout, q->data, PGRES_COPY_OUT);
    PQclear(res);
    destroyPQExpBuffer(clistBuf);

    for (;;)
    {
        ret = PQgetCopyData(conn, &copybuf, 0);

        if (ret < 0)
            break;              /* done or error */

        if (copybuf)
        {
            WriteData(fout, copybuf, ret);
            PQfreemem(copybuf);
        }

        /* ----------
         * THROTTLE:
         *
         * There was considerable discussion in late July, 2000 regarding
         * slowing down pg_dump when backing up large tables. Users with both
         * slow & fast (multi-processor) machines experienced performance
         * degradation when doing a backup.
         *
         * Initial attempts based on sleeping for a number of ms for each ms
         * of work were deemed too complex, then a simple 'sleep in each loop'
         * implementation was suggested. The latter failed because the loop
         * was too tight. Finally, the following was implemented:
         *
         * If throttle is non-zero, then
         *      See how long since the last sleep.
         *      Work out how long to sleep (based on ratio).
         *      If sleep is more than 100ms, then
         *          sleep
         *          reset timer
         *      EndIf
         * EndIf
         *
         * where the throttle value was the number of ms to sleep per ms of
         * work. The calculation was done in each loop.
         *
         * Most of the hard work is done in the backend, and this solution
         * still did not work particularly well: on slow machines, the ratio
         * was 50:1, and on medium paced machines, 1:1, and on fast
         * multi-processor machines, it had little or no effect, for reasons
         * that were unclear.
         *
         * Further discussion ensued, and the proposal was dropped.
         *
         * For those people who want this feature, it can be implemented using
         * gettimeofday in each loop, calculating the time since last sleep,
         * multiplying that by the sleep ratio, then if the result is more
         * than a preset 'minimum sleep time' (say 100ms), call the 'select'
         * function to sleep for a subsecond period ie.
         *
         * select(0, NULL, NULL, NULL, &tvi);
         *
         * This will return after the interval specified in the structure tvi.
         * Finally, call gettimeofday again to save the 'last sleep time'.
         * ----------
         */
    }
    archprintf(fout, "\\.\n\n\n");

    if (ret == -2)
    {
        /* copy data transfer failed */
        write_msg(NULL, "Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.\n", classname);
        write_msg(NULL, "Error message from server: %s", PQerrorMessage(conn));
        write_msg(NULL, "The command was: %s\n", q->data);
        exit_nicely(1);
    }

    /* Check command status and return to normal libpq state */
    res = PQgetResult(conn);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        write_msg(NULL, "Dumping the contents of table \"%s\" failed: PQgetResult() failed.\n", classname);
        write_msg(NULL, "Error message from server: %s", PQerrorMessage(conn));
        write_msg(NULL, "The command was: %s\n", q->data);
        exit_nicely(1);
    }
    PQclear(res);

    destroyPQExpBuffer(q);
    return 1;
}

static int dumpTableData_insert ( Archive fout,
void *  dcontext 
) [static]

Definition at line 1545 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, archprintf(), archputs(), BITOID, BOOLOID, column_inserts, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, ExecuteSqlQuery(), ExecuteSqlStatement(), _tableDataInfo::filtercond, FLOAT4OID, FLOAT8OID, fmtId(), fmtQualifiedId(), INT2OID, INT4OID, INT8OID, _dumpableObject::name, NUMERICOID, OIDOID, PGRES_TUPLES_OK, PQclear(), PQfname(), PQftype(), PQgetisnull(), PQgetvalue(), PQnfields(), PQntuples(), Archive::remoteVersion, resetPQExpBuffer(), selectSourceSchema(), _tableDataInfo::tdtable, and VARBITOID.

{
    TableDataInfo *tdinfo = (TableDataInfo *) dcontext;
    TableInfo  *tbinfo = tdinfo->tdtable;
    const char *classname = tbinfo->dobj.name;
    PQExpBuffer q = createPQExpBuffer();
    PGresult   *res;
    int         tuple;
    int         nfields;
    int         field;

    /*
     * Make sure we are in proper schema.  We will qualify the table name
     * below anyway (in case its name conflicts with a pg_catalog table); but
     * this ensures reproducible results in case the table contains regproc,
     * regclass, etc columns.
     */
    selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

    if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(q, "DECLARE _pg_dump_cursor CURSOR FOR "
                          "SELECT * FROM ONLY %s",
                          fmtQualifiedId(fout->remoteVersion,
                                         tbinfo->dobj.namespace->dobj.name,
                                         classname));
    }
    else
    {
        appendPQExpBuffer(q, "DECLARE _pg_dump_cursor CURSOR FOR "
                          "SELECT * FROM %s",
                          fmtQualifiedId(fout->remoteVersion,
                                         tbinfo->dobj.namespace->dobj.name,
                                         classname));
    }
    if (tdinfo->filtercond)
        appendPQExpBuffer(q, " %s", tdinfo->filtercond);

    ExecuteSqlStatement(fout, q->data);

    while (1)
    {
        res = ExecuteSqlQuery(fout, "FETCH 100 FROM _pg_dump_cursor",
                              PGRES_TUPLES_OK);
        nfields = PQnfields(res);
        for (tuple = 0; tuple < PQntuples(res); tuple++)
        {
            archprintf(fout, "INSERT INTO %s ", fmtId(classname));
            if (nfields == 0)
            {
                /* corner case for zero-column table */
                archprintf(fout, "DEFAULT VALUES;\n");
                continue;
            }
            if (column_inserts)
            {
                resetPQExpBuffer(q);
                appendPQExpBuffer(q, "(");
                for (field = 0; field < nfields; field++)
                {
                    if (field > 0)
                        appendPQExpBuffer(q, ", ");
                    appendPQExpBufferStr(q, fmtId(PQfname(res, field)));
                }
                appendPQExpBuffer(q, ") ");
                archputs(q->data, fout);
            }
            archprintf(fout, "VALUES (");
            for (field = 0; field < nfields; field++)
            {
                if (field > 0)
                    archprintf(fout, ", ");
                if (PQgetisnull(res, tuple, field))
                {
                    archprintf(fout, "NULL");
                    continue;
                }

                /* XXX This code is partially duplicated in ruleutils.c */
                switch (PQftype(res, field))
                {
                    case INT2OID:
                    case INT4OID:
                    case INT8OID:
                    case OIDOID:
                    case FLOAT4OID:
                    case FLOAT8OID:
                    case NUMERICOID:
                        {
                            /*
                             * These types are printed without quotes unless
                             * they contain values that aren't accepted by the
                             * scanner unquoted (e.g., 'NaN').  Note that
                             * strtod() and friends might accept NaN, so we
                             * can't use that to test.
                             *
                             * In reality we only need to defend against
                             * infinity and NaN, so we need not get too crazy
                             * about pattern matching here.
                             */
                            const char *s = PQgetvalue(res, tuple, field);

                            if (strspn(s, "0123456789 +-eE.") == strlen(s))
                                archprintf(fout, "%s", s);
                            else
                                archprintf(fout, "'%s'", s);
                        }
                        break;

                    case BITOID:
                    case VARBITOID:
                        archprintf(fout, "B'%s'",
                                   PQgetvalue(res, tuple, field));
                        break;

                    case BOOLOID:
                        if (strcmp(PQgetvalue(res, tuple, field), "t") == 0)
                            archprintf(fout, "true");
                        else
                            archprintf(fout, "false");
                        break;

                    default:
                        /* All other types are printed as string literals. */
                        resetPQExpBuffer(q);
                        appendStringLiteralAH(q,
                                              PQgetvalue(res, tuple, field),
                                              fout);
                        archputs(q->data, fout);
                        break;
                }
            }
            archprintf(fout, ");\n");
        }

        if (PQntuples(res) <= 0)
        {
            PQclear(res);
            break;
        }
        PQclear(res);
    }

    archprintf(fout, "\n\n");

    ExecuteSqlStatement(fout, "CLOSE _pg_dump_cursor");

    destroyPQExpBuffer(q);
    return 1;
}

static void dumpTableSchema ( Archive fout,
TableInfo tbinfo 
) [static]

Definition at line 12791 of file pg_dump.c.

References _attrDefInfo::adef_expr, appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), _tableInfo::attalign, _tableInfo::attcollation, _tableInfo::attfdwoptions, _tableInfo::attisdropped, _tableInfo::attislocal, _tableInfo::attlen, _tableInfo::attnames, _tableInfo::attoptions, _tableInfo::attrdefs, _tableInfo::attstattarget, _tableInfo::attstorage, _tableInfo::atttypmod, _tableInfo::atttypnames, binary_upgrade, binary_upgrade_extension_member(), binary_upgrade_set_pg_class_oids(), binary_upgrade_set_type_oids_by_rel_oid(), _dumpableObject::catId, _tableInfo::checkexprs, _constraintInfo::condef, _constraintInfo::conislocal, createPQExpBuffer(), createViewAsClause(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _collInfo::dobj, _tableInfo::dobj, _dumpableObject::dumpId, dumpTableComment(), dumpTableConstraintComment(), dumpTableSecLabel(), ExecuteSqlQueryForSingleRow(), findCollationByOid(), fmtId(), _tableInfo::frozenxid, _tableInfo::hasoids, _tableInfo::inhNotNull, myFormatType(), _dumpableObject::name, _tableInfo::ncheck, _tableInfo::notnull, NULL, _tableInfo::numatts, _tableInfo::numParents, CatalogId::oid, OidIsValid, _tableInfo::parents, pg_strdup(), PQclear(), PQfnumber(), PQgetvalue(), _tableInfo::relkind, RELKIND_FOREIGN_TABLE, RELKIND_MATVIEW, RELKIND_RELATION, RELKIND_VIEW, _tableInfo::reloftype, _tableInfo::reloptions, _tableInfo::relpersistence, RELPERSISTENCE_UNLOGGED, _tableInfo::reltablespace, Archive::remoteVersion, _tableInfo::rolname, SECTION_PRE_DATA, selectSourceSchema(), _constraintInfo::separate, _attrDefInfo::separate, shouldPrintColumn(), _tableInfo::toast_frozenxid, _tableInfo::toast_oid, _tableInfo::toast_reloptions, and _tableInfo::typstorage.

Referenced by dumpTable().

{
    PQExpBuffer q = createPQExpBuffer();
    PQExpBuffer delq = createPQExpBuffer();
    PQExpBuffer labelq = createPQExpBuffer();
    int         numParents;
    TableInfo **parents;
    int         actual_atts;    /* number of attrs in this CREATE statement */
    const char *reltypename;
    char       *storage;
    char       *srvname;
    char       *ftoptions;
    int         j,
                k;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

    if (binary_upgrade)
        binary_upgrade_set_type_oids_by_rel_oid(fout, q,
                                                tbinfo->dobj.catId.oid);

    /* Is it a table or a view? */
    if (tbinfo->relkind == RELKIND_VIEW)
    {
        PQExpBuffer result;

        reltypename = "VIEW";

        /*
         * DROP must be fully qualified in case same name appears in
         * pg_catalog
         */
        appendPQExpBuffer(delq, "DROP VIEW %s.",
                          fmtId(tbinfo->dobj.namespace->dobj.name));
        appendPQExpBuffer(delq, "%s;\n",
                          fmtId(tbinfo->dobj.name));

        if (binary_upgrade)
            binary_upgrade_set_pg_class_oids(fout, q,
                                             tbinfo->dobj.catId.oid, false);

        appendPQExpBuffer(q, "CREATE VIEW %s", fmtId(tbinfo->dobj.name));
        if (tbinfo->reloptions && strlen(tbinfo->reloptions) > 0)
            appendPQExpBuffer(q, " WITH (%s)", tbinfo->reloptions);
        result = createViewAsClause(fout, tbinfo);
        appendPQExpBuffer(q, " AS\n%s;\n", result->data);
        destroyPQExpBuffer(result);

        appendPQExpBuffer(labelq, "VIEW %s",
                          fmtId(tbinfo->dobj.name));
    }
    else
    {
        switch (tbinfo->relkind)
        {
            case (RELKIND_FOREIGN_TABLE):
                {
                    PQExpBuffer query = createPQExpBuffer();
                    PGresult   *res;
                    int         i_srvname;
                    int         i_ftoptions;

                    reltypename = "FOREIGN TABLE";

                    /* retrieve name of foreign server and generic options */
                    appendPQExpBuffer(query,
                                      "SELECT fs.srvname, "
                                      "pg_catalog.array_to_string(ARRAY("
                             "SELECT pg_catalog.quote_ident(option_name) || "
                             "' ' || pg_catalog.quote_literal(option_value) "
                            "FROM pg_catalog.pg_options_to_table(ftoptions) "
                                      "ORDER BY option_name"
                                      "), E',\n    ') AS ftoptions "
                                      "FROM pg_catalog.pg_foreign_table ft "
                                      "JOIN pg_catalog.pg_foreign_server fs "
                                      "ON (fs.oid = ft.ftserver) "
                                      "WHERE ft.ftrelid = '%u'",
                                      tbinfo->dobj.catId.oid);
                    res = ExecuteSqlQueryForSingleRow(fout, query->data);
                    i_srvname = PQfnumber(res, "srvname");
                    i_ftoptions = PQfnumber(res, "ftoptions");
                    srvname = pg_strdup(PQgetvalue(res, 0, i_srvname));
                    ftoptions = pg_strdup(PQgetvalue(res, 0, i_ftoptions));
                    PQclear(res);
                    destroyPQExpBuffer(query);
                    break;
                }
            case (RELKIND_MATVIEW):
                reltypename = "MATERIALIZED VIEW";
                srvname = NULL;
                ftoptions = NULL;
                break;
            default:
                reltypename = "TABLE";
                srvname = NULL;
                ftoptions = NULL;
        }

        numParents = tbinfo->numParents;
        parents = tbinfo->parents;

        /*
         * DROP must be fully qualified in case same name appears in
         * pg_catalog
         */
        appendPQExpBuffer(delq, "DROP %s %s.", reltypename,
                          fmtId(tbinfo->dobj.namespace->dobj.name));
        appendPQExpBuffer(delq, "%s;\n",
                          fmtId(tbinfo->dobj.name));

        appendPQExpBuffer(labelq, "%s %s", reltypename,
                          fmtId(tbinfo->dobj.name));

        if (binary_upgrade)
            binary_upgrade_set_pg_class_oids(fout, q,
                                             tbinfo->dobj.catId.oid, false);

        appendPQExpBuffer(q, "CREATE %s%s %s",
                          tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED ?
                          "UNLOGGED " : "",
                          reltypename,
                          fmtId(tbinfo->dobj.name));

        /*
         * Attach to type, if reloftype; except in case of a binary upgrade,
         * we dump the table normally and attach it to the type afterward.
         */
        if (tbinfo->reloftype && !binary_upgrade)
            appendPQExpBuffer(q, " OF %s", tbinfo->reloftype);

        if (tbinfo->relkind != RELKIND_MATVIEW)
        {
            /* Dump the attributes */
            actual_atts = 0;
            for (j = 0; j < tbinfo->numatts; j++)
            {
                /*
                 * Normally, dump if it's locally defined in this table, and
                 * not dropped.  But for binary upgrade, we'll dump all the
                 * columns, and then fix up the dropped and nonlocal cases
                 * below.
                 */
                if (shouldPrintColumn(tbinfo, j))
                {
                    /*
                     * Default value --- suppress if to be printed separately.
                     */
                    bool        has_default = (tbinfo->attrdefs[j] != NULL &&
                                             !tbinfo->attrdefs[j]->separate);

                    /*
                     * Not Null constraint --- suppress if inherited, except
                     * in binary-upgrade case where that won't work.
                     */
                    bool        has_notnull = (tbinfo->notnull[j] &&
                                               (!tbinfo->inhNotNull[j] ||
                                                binary_upgrade));

                    /* Skip column if fully defined by reloftype */
                    if (tbinfo->reloftype &&
                        !has_default && !has_notnull && !binary_upgrade)
                        continue;

                    /* Format properly if not first attr */
                    if (actual_atts == 0)
                        appendPQExpBuffer(q, " (");
                    else
                        appendPQExpBuffer(q, ",");
                    appendPQExpBuffer(q, "\n    ");
                    actual_atts++;

                    /* Attribute name */
                    appendPQExpBuffer(q, "%s",
                                      fmtId(tbinfo->attnames[j]));

                    if (tbinfo->attisdropped[j])
                    {
                        /*
                         * ALTER TABLE DROP COLUMN clears
                         * pg_attribute.atttypid, so we will not have gotten a
                         * valid type name; insert INTEGER as a stopgap. We'll
                         * clean things up later.
                         */
                        appendPQExpBuffer(q, " INTEGER /* dummy */");
                        /* Skip all the rest, too */
                        continue;
                    }

                    /* Attribute type */
                    if (tbinfo->reloftype && !binary_upgrade)
                    {
                        appendPQExpBuffer(q, " WITH OPTIONS");
                    }
                    else if (fout->remoteVersion >= 70100)
                    {
                        appendPQExpBuffer(q, " %s",
                                          tbinfo->atttypnames[j]);
                    }
                    else
                    {
                        /* If no format_type, fake it */
                        appendPQExpBuffer(q, " %s",
                                          myFormatType(tbinfo->atttypnames[j],
                                                       tbinfo->atttypmod[j]));
                    }

                    /* Add collation if not default for the type */
                    if (OidIsValid(tbinfo->attcollation[j]))
                    {
                        CollInfo   *coll;

                        coll = findCollationByOid(tbinfo->attcollation[j]);
                        if (coll)
                        {
                            /* always schema-qualify, don't try to be smart */
                            appendPQExpBuffer(q, " COLLATE %s.",
                                     fmtId(coll->dobj.namespace->dobj.name));
                            appendPQExpBuffer(q, "%s",
                                              fmtId(coll->dobj.name));
                        }
                    }

                    if (has_default)
                        appendPQExpBuffer(q, " DEFAULT %s",
                                          tbinfo->attrdefs[j]->adef_expr);

                    if (has_notnull)
                        appendPQExpBuffer(q, " NOT NULL");
                }
            }

            /*
             * Add non-inherited CHECK constraints, if any.
             */
            for (j = 0; j < tbinfo->ncheck; j++)
            {
                ConstraintInfo *constr = &(tbinfo->checkexprs[j]);

                if (constr->separate || !constr->conislocal)
                    continue;

                if (actual_atts == 0)
                    appendPQExpBuffer(q, " (\n    ");
                else
                    appendPQExpBuffer(q, ",\n    ");

                appendPQExpBuffer(q, "CONSTRAINT %s ",
                                  fmtId(constr->dobj.name));
                appendPQExpBuffer(q, "%s", constr->condef);

                actual_atts++;
            }

            if (actual_atts)
                appendPQExpBuffer(q, "\n)");
            else if (!(tbinfo->reloftype && !binary_upgrade))
            {
                /*
                 * We must have a parenthesized attribute list, even though
                 * empty, when not using the OF TYPE syntax.
                 */
                appendPQExpBuffer(q, " (\n)");
            }

            if (numParents > 0 && !binary_upgrade)
            {
                appendPQExpBuffer(q, "\nINHERITS (");
                for (k = 0; k < numParents; k++)
                {
                    TableInfo  *parentRel = parents[k];

                    if (k > 0)
                        appendPQExpBuffer(q, ", ");
                    if (parentRel->dobj.namespace != tbinfo->dobj.namespace)
                        appendPQExpBuffer(q, "%s.",
                                fmtId(parentRel->dobj.namespace->dobj.name));
                    appendPQExpBuffer(q, "%s",
                                      fmtId(parentRel->dobj.name));
                }
                appendPQExpBuffer(q, ")");
            }

            if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
                appendPQExpBuffer(q, "\nSERVER %s", fmtId(srvname));
        }

        if ((tbinfo->reloptions && strlen(tbinfo->reloptions) > 0) ||
          (tbinfo->toast_reloptions && strlen(tbinfo->toast_reloptions) > 0))
        {
            bool        addcomma = false;

            appendPQExpBuffer(q, "\nWITH (");
            if (tbinfo->reloptions && strlen(tbinfo->reloptions) > 0)
            {
                addcomma = true;
                appendPQExpBuffer(q, "%s", tbinfo->reloptions);
            }
            if (tbinfo->toast_reloptions && strlen(tbinfo->toast_reloptions) > 0)
            {
                appendPQExpBuffer(q, "%s%s", addcomma ? ", " : "",
                                  tbinfo->toast_reloptions);
            }
            appendPQExpBuffer(q, ")");
        }

        /* Dump generic options if any */
        if (ftoptions && ftoptions[0])
            appendPQExpBuffer(q, "\nOPTIONS (\n    %s\n)", ftoptions);

        /*
         * For materialized views, create the AS clause just like a view.
         */
        if (tbinfo->relkind == RELKIND_MATVIEW)
        {
            PQExpBuffer result;

            result = createViewAsClause(fout, tbinfo);
            appendPQExpBuffer(q, " AS\n%s\n  WITH NO DATA;\n",
                              result->data);
            destroyPQExpBuffer(result);
        }
        else
            appendPQExpBuffer(q, ";\n");

        /*
         * To create binary-compatible heap files, we have to ensure the same
         * physical column order, including dropped columns, as in the
         * original.  Therefore, we create dropped columns above and drop them
         * here, also updating their attlen/attalign values so that the
         * dropped column can be skipped properly.  (We do not bother with
         * restoring the original attbyval setting.)  Also, inheritance
         * relationships are set up by doing ALTER INHERIT rather than using
         * an INHERITS clause --- the latter would possibly mess up the column
         * order.  That also means we have to take care about setting
         * attislocal correctly, plus fix up any inherited CHECK constraints.
         * Analogously, we set up typed tables using ALTER TABLE / OF here.
         */
        if (binary_upgrade && tbinfo->relkind == RELKIND_RELATION)
        {
            for (j = 0; j < tbinfo->numatts; j++)
            {
                if (tbinfo->attisdropped[j])
                {
                    appendPQExpBuffer(q, "\n-- For binary upgrade, recreate dropped column.\n");
                    appendPQExpBuffer(q, "UPDATE pg_catalog.pg_attribute\n"
                                      "SET attlen = %d, "
                                      "attalign = '%c', attbyval = false\n"
                                      "WHERE attname = ",
                                      tbinfo->attlen[j],
                                      tbinfo->attalign[j]);
                    appendStringLiteralAH(q, tbinfo->attnames[j], fout);
                    appendPQExpBuffer(q, "\n  AND attrelid = ");
                    appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
                    appendPQExpBuffer(q, "::pg_catalog.regclass;\n");

                    appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                                      fmtId(tbinfo->dobj.name));
                    appendPQExpBuffer(q, "DROP COLUMN %s;\n",
                                      fmtId(tbinfo->attnames[j]));
                }
                else if (!tbinfo->attislocal[j])
                {
                    appendPQExpBuffer(q, "\n-- For binary upgrade, recreate inherited column.\n");
                    appendPQExpBuffer(q, "UPDATE pg_catalog.pg_attribute\n"
                                      "SET attislocal = false\n"
                                      "WHERE attname = ");
                    appendStringLiteralAH(q, tbinfo->attnames[j], fout);
                    appendPQExpBuffer(q, "\n  AND attrelid = ");
                    appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
                    appendPQExpBuffer(q, "::pg_catalog.regclass;\n");
                }
            }

            for (k = 0; k < tbinfo->ncheck; k++)
            {
                ConstraintInfo *constr = &(tbinfo->checkexprs[k]);

                if (constr->separate || constr->conislocal)
                    continue;

                appendPQExpBuffer(q, "\n-- For binary upgrade, set up inherited constraint.\n");
                appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                                  fmtId(tbinfo->dobj.name));
                appendPQExpBuffer(q, " ADD CONSTRAINT %s ",
                                  fmtId(constr->dobj.name));
                appendPQExpBuffer(q, "%s;\n", constr->condef);
                appendPQExpBuffer(q, "UPDATE pg_catalog.pg_constraint\n"
                                  "SET conislocal = false\n"
                                  "WHERE contype = 'c' AND conname = ");
                appendStringLiteralAH(q, constr->dobj.name, fout);
                appendPQExpBuffer(q, "\n  AND conrelid = ");
                appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
                appendPQExpBuffer(q, "::pg_catalog.regclass;\n");
            }

            if (numParents > 0)
            {
                appendPQExpBuffer(q, "\n-- For binary upgrade, set up inheritance this way.\n");
                for (k = 0; k < numParents; k++)
                {
                    TableInfo  *parentRel = parents[k];

                    appendPQExpBuffer(q, "ALTER TABLE ONLY %s INHERIT ",
                                      fmtId(tbinfo->dobj.name));
                    if (parentRel->dobj.namespace != tbinfo->dobj.namespace)
                        appendPQExpBuffer(q, "%s.",
                                fmtId(parentRel->dobj.namespace->dobj.name));
                    appendPQExpBuffer(q, "%s;\n",
                                      fmtId(parentRel->dobj.name));
                }
            }

            if (tbinfo->reloftype)
            {
                appendPQExpBuffer(q, "\n-- For binary upgrade, set up typed tables this way.\n");
                appendPQExpBuffer(q, "ALTER TABLE ONLY %s OF %s;\n",
                                  fmtId(tbinfo->dobj.name),
                                  tbinfo->reloftype);
            }

            appendPQExpBuffer(q, "\n-- For binary upgrade, set heap's relfrozenxid\n");
            appendPQExpBuffer(q, "UPDATE pg_catalog.pg_class\n"
                              "SET relfrozenxid = '%u'\n"
                              "WHERE oid = ",
                              tbinfo->frozenxid);
            appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
            appendPQExpBuffer(q, "::pg_catalog.regclass;\n");

            if (tbinfo->toast_oid)
            {
                /* We preserve the toast oids, so we can use it during restore */
                appendPQExpBuffer(q, "\n-- For binary upgrade, set toast's relfrozenxid\n");
                appendPQExpBuffer(q, "UPDATE pg_catalog.pg_class\n"
                                  "SET relfrozenxid = '%u'\n"
                                  "WHERE oid = '%u';\n",
                                  tbinfo->toast_frozenxid, tbinfo->toast_oid);
            }
        }

        /*
         * Dump additional per-column properties that we can't handle in the
         * main CREATE TABLE command.
         */
        for (j = 0; j < tbinfo->numatts; j++)
        {
            /* None of this applies to dropped columns */
            if (tbinfo->attisdropped[j])
                continue;

            /*
             * If we didn't dump the column definition explicitly above, and
             * it is NOT NULL and did not inherit that property from a parent,
             * we have to mark it separately.
             */
            if (!shouldPrintColumn(tbinfo, j) &&
                tbinfo->notnull[j] && !tbinfo->inhNotNull[j])
            {
                appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                                  fmtId(tbinfo->dobj.name));
                appendPQExpBuffer(q, "ALTER COLUMN %s SET NOT NULL;\n",
                                  fmtId(tbinfo->attnames[j]));
            }

            /*
             * Dump per-column statistics information. We only issue an ALTER
             * TABLE statement if the attstattarget entry for this column is
             * non-negative (i.e. it's not the default value)
             */
            if (tbinfo->attstattarget[j] >= 0)
            {
                appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                                  fmtId(tbinfo->dobj.name));
                appendPQExpBuffer(q, "ALTER COLUMN %s ",
                                  fmtId(tbinfo->attnames[j]));
                appendPQExpBuffer(q, "SET STATISTICS %d;\n",
                                  tbinfo->attstattarget[j]);
            }

            /*
             * Dump per-column storage information.  The statement is only
             * dumped if the storage has been changed from the type's default.
             */
            if (tbinfo->attstorage[j] != tbinfo->typstorage[j])
            {
                switch (tbinfo->attstorage[j])
                {
                    case 'p':
                        storage = "PLAIN";
                        break;
                    case 'e':
                        storage = "EXTERNAL";
                        break;
                    case 'm':
                        storage = "MAIN";
                        break;
                    case 'x':
                        storage = "EXTENDED";
                        break;
                    default:
                        storage = NULL;
                }

                /*
                 * Only dump the statement if it's a storage type we recognize
                 */
                if (storage != NULL)
                {
                    appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                                      fmtId(tbinfo->dobj.name));
                    appendPQExpBuffer(q, "ALTER COLUMN %s ",
                                      fmtId(tbinfo->attnames[j]));
                    appendPQExpBuffer(q, "SET STORAGE %s;\n",
                                      storage);
                }
            }

            /*
             * Dump per-column attributes.
             */
            if (tbinfo->attoptions[j] && tbinfo->attoptions[j][0] != '\0')
            {
                appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
                                  fmtId(tbinfo->dobj.name));
                appendPQExpBuffer(q, "ALTER COLUMN %s ",
                                  fmtId(tbinfo->attnames[j]));
                appendPQExpBuffer(q, "SET (%s);\n",
                                  tbinfo->attoptions[j]);
            }

            /*
             * Dump per-column fdw options.
             */
            if (tbinfo->relkind == RELKIND_FOREIGN_TABLE &&
                tbinfo->attfdwoptions[j] &&
                tbinfo->attfdwoptions[j][0] != '\0')
            {
                appendPQExpBuffer(q, "ALTER FOREIGN TABLE %s ",
                                  fmtId(tbinfo->dobj.name));
                appendPQExpBuffer(q, "ALTER COLUMN %s ",
                                  fmtId(tbinfo->attnames[j]));
                appendPQExpBuffer(q, "OPTIONS (\n    %s\n);\n",
                                  tbinfo->attfdwoptions[j]);
            }
        }
    }

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tbinfo->dobj, labelq->data);

    ArchiveEntry(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
                 tbinfo->dobj.name,
                 tbinfo->dobj.namespace->dobj.name,
            (tbinfo->relkind == RELKIND_VIEW) ? NULL : tbinfo->reltablespace,
                 tbinfo->rolname,
               (strcmp(reltypename, "TABLE") == 0) ? tbinfo->hasoids : false,
                 reltypename, SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);


    /* Dump Table Comments */
    dumpTableComment(fout, tbinfo, reltypename);

    /* Dump Table Security Labels */
    dumpTableSecLabel(fout, tbinfo, reltypename);

    /* Dump comments on inlined table constraints */
    for (j = 0; j < tbinfo->ncheck; j++)
    {
        ConstraintInfo *constr = &(tbinfo->checkexprs[j]);

        if (constr->separate || !constr->conislocal)
            continue;

        dumpTableConstraintComment(fout, constr);
    }

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpTableSecLabel ( Archive fout,
TableInfo tbinfo,
const char *  reltypename 
) [static]

Definition at line 12443 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, ArchiveEntry(), _dumpableObject::catId, createDumpId(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dumpId, findSecLabels(), fmtId(), getAttrName(), i, SecLabelItem::label, label, PQExpBufferData::len, _dumpableObject::name, no_security_labels, NULL, SecLabelItem::objsubid, CatalogId::oid, SecLabelItem::provider, resetPQExpBuffer(), _tableInfo::rolname, SECTION_NONE, and CatalogId::tableoid.

Referenced by dumpTableSchema().

{
    SecLabelItem *labels;
    int         nlabels;
    int         i;
    PQExpBuffer query;
    PQExpBuffer target;

    /* do nothing, if --no-security-labels is supplied */
    if (no_security_labels)
        return;

    /* SecLabel are SCHEMA not data */
    if (dataOnly)
        return;

    /* Search for comments associated with relation, using table */
    nlabels = findSecLabels(fout,
                            tbinfo->dobj.catId.tableoid,
                            tbinfo->dobj.catId.oid,
                            &labels);

    /* If security labels exist, build SECURITY LABEL statements */
    if (nlabels <= 0)
        return;

    query = createPQExpBuffer();
    target = createPQExpBuffer();

    for (i = 0; i < nlabels; i++)
    {
        const char *colname;
        const char *provider = labels[i].provider;
        const char *label = labels[i].label;
        int         objsubid = labels[i].objsubid;

        resetPQExpBuffer(target);
        if (objsubid == 0)
        {
            appendPQExpBuffer(target, "%s %s", reltypename,
                              fmtId(tbinfo->dobj.name));
        }
        else
        {
            colname = getAttrName(objsubid, tbinfo);
            /* first fmtId result must be consumed before calling it again */
            appendPQExpBuffer(target, "COLUMN %s", fmtId(tbinfo->dobj.name));
            appendPQExpBuffer(target, ".%s", fmtId(colname));
        }
        appendPQExpBuffer(query, "SECURITY LABEL FOR %s ON %s IS ",
                          fmtId(provider), target->data);
        appendStringLiteralAH(query, label, fout);
        appendPQExpBuffer(query, ";\n");
    }
    if (query->len > 0)
    {
        resetPQExpBuffer(target);
        appendPQExpBuffer(target, "%s %s", reltypename,
                          fmtId(tbinfo->dobj.name));
        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     target->data,
                     tbinfo->dobj.namespace->dobj.name,
                     NULL, tbinfo->rolname,
                     false, "SECURITY LABEL", SECTION_NONE,
                     query->data, "", NULL,
                     &(tbinfo->dobj.dumpId), 1,
                     NULL, NULL);
    }
    destroyPQExpBuffer(query);
    destroyPQExpBuffer(target);
}

static void dumpTrigger ( Archive fout,
TriggerInfo tginfo 
) [static]

Definition at line 14098 of file pg_dump.c.

References appendPQExpBuffer(), appendPQExpBufferStr(), appendStringLiteralAH, ArchiveEntry(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tableInfo::dobj, _triggerInfo::dobj, dumpComment(), _dumpableObject::dumpId, exit_nicely, fmtId(), free, _dumpableObject::name, NULL, OidIsValid, PQunescapeBytea(), Archive::remoteVersion, _tableInfo::rolname, SECTION_POST_DATA, _triggerInfo::tgargs, _triggerInfo::tgconstrname, _triggerInfo::tgconstrrelid, _triggerInfo::tgconstrrelname, _triggerInfo::tgdef, _triggerInfo::tgdeferrable, _triggerInfo::tgenabled, _triggerInfo::tgfname, _triggerInfo::tginitdeferred, _triggerInfo::tgisconstraint, _triggerInfo::tgnargs, _triggerInfo::tgtable, _triggerInfo::tgtype, TRIGGER_FOR_AFTER, TRIGGER_FOR_BEFORE, TRIGGER_FOR_DELETE, TRIGGER_FOR_INSERT, TRIGGER_FOR_INSTEAD, TRIGGER_FOR_ROW, TRIGGER_FOR_TRUNCATE, TRIGGER_FOR_UPDATE, and write_msg().

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = tginfo->tgtable;
    PQExpBuffer query;
    PQExpBuffer delqry;
    PQExpBuffer labelq;
    char       *tgargs;
    size_t      lentgargs;
    const char *p;
    int         findx;

    if (dataOnly)
        return;

    query = createPQExpBuffer();
    delqry = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delqry, "DROP TRIGGER %s ",
                      fmtId(tginfo->dobj.name));
    appendPQExpBuffer(delqry, "ON %s.",
                      fmtId(tbinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delqry, "%s;\n",
                      fmtId(tbinfo->dobj.name));

    if (tginfo->tgdef)
    {
        appendPQExpBuffer(query, "%s;\n", tginfo->tgdef);
    }
    else
    {
        if (tginfo->tgisconstraint)
        {
            appendPQExpBuffer(query, "CREATE CONSTRAINT TRIGGER ");
            appendPQExpBufferStr(query, fmtId(tginfo->tgconstrname));
        }
        else
        {
            appendPQExpBuffer(query, "CREATE TRIGGER ");
            appendPQExpBufferStr(query, fmtId(tginfo->dobj.name));
        }
        appendPQExpBuffer(query, "\n    ");

        /* Trigger type */
        if (TRIGGER_FOR_BEFORE(tginfo->tgtype))
            appendPQExpBuffer(query, "BEFORE");
        else if (TRIGGER_FOR_AFTER(tginfo->tgtype))
            appendPQExpBuffer(query, "AFTER");
        else if (TRIGGER_FOR_INSTEAD(tginfo->tgtype))
            appendPQExpBuffer(query, "INSTEAD OF");
        else
        {
            write_msg(NULL, "unexpected tgtype value: %d\n", tginfo->tgtype);
            exit_nicely(1);
        }

        findx = 0;
        if (TRIGGER_FOR_INSERT(tginfo->tgtype))
        {
            appendPQExpBuffer(query, " INSERT");
            findx++;
        }
        if (TRIGGER_FOR_DELETE(tginfo->tgtype))
        {
            if (findx > 0)
                appendPQExpBuffer(query, " OR DELETE");
            else
                appendPQExpBuffer(query, " DELETE");
            findx++;
        }
        if (TRIGGER_FOR_UPDATE(tginfo->tgtype))
        {
            if (findx > 0)
                appendPQExpBuffer(query, " OR UPDATE");
            else
                appendPQExpBuffer(query, " UPDATE");
            findx++;
        }
        if (TRIGGER_FOR_TRUNCATE(tginfo->tgtype))
        {
            if (findx > 0)
                appendPQExpBuffer(query, " OR TRUNCATE");
            else
                appendPQExpBuffer(query, " TRUNCATE");
            findx++;
        }
        appendPQExpBuffer(query, " ON %s\n",
                          fmtId(tbinfo->dobj.name));

        if (tginfo->tgisconstraint)
        {
            if (OidIsValid(tginfo->tgconstrrelid))
            {
                /* If we are using regclass, name is already quoted */
                if (fout->remoteVersion >= 70300)
                    appendPQExpBuffer(query, "    FROM %s\n    ",
                                      tginfo->tgconstrrelname);
                else
                    appendPQExpBuffer(query, "    FROM %s\n    ",
                                      fmtId(tginfo->tgconstrrelname));
            }
            if (!tginfo->tgdeferrable)
                appendPQExpBuffer(query, "NOT ");
            appendPQExpBuffer(query, "DEFERRABLE INITIALLY ");
            if (tginfo->tginitdeferred)
                appendPQExpBuffer(query, "DEFERRED\n");
            else
                appendPQExpBuffer(query, "IMMEDIATE\n");
        }

        if (TRIGGER_FOR_ROW(tginfo->tgtype))
            appendPQExpBuffer(query, "    FOR EACH ROW\n    ");
        else
            appendPQExpBuffer(query, "    FOR EACH STATEMENT\n    ");

        /* In 7.3, result of regproc is already quoted */
        if (fout->remoteVersion >= 70300)
            appendPQExpBuffer(query, "EXECUTE PROCEDURE %s(",
                              tginfo->tgfname);
        else
            appendPQExpBuffer(query, "EXECUTE PROCEDURE %s(",
                              fmtId(tginfo->tgfname));

        tgargs = (char *) PQunescapeBytea((unsigned char *) tginfo->tgargs,
                                          &lentgargs);
        p = tgargs;
        for (findx = 0; findx < tginfo->tgnargs; findx++)
        {
            /* find the embedded null that terminates this trigger argument */
            size_t      tlen = strlen(p);

            if (p + tlen >= tgargs + lentgargs)
            {
                /* hm, not found before end of bytea value... */
                write_msg(NULL, "invalid argument string (%s) for trigger \"%s\" on table \"%s\"\n",
                          tginfo->tgargs,
                          tginfo->dobj.name,
                          tbinfo->dobj.name);
                exit_nicely(1);
            }

            if (findx > 0)
                appendPQExpBuffer(query, ", ");
            appendStringLiteralAH(query, p, fout);
            p += tlen + 1;
        }
        free(tgargs);
        appendPQExpBuffer(query, ");\n");
    }

    if (tginfo->tgenabled != 't' && tginfo->tgenabled != 'O')
    {
        appendPQExpBuffer(query, "\nALTER TABLE %s ",
                          fmtId(tbinfo->dobj.name));
        switch (tginfo->tgenabled)
        {
            case 'D':
            case 'f':
                appendPQExpBuffer(query, "DISABLE");
                break;
            case 'A':
                appendPQExpBuffer(query, "ENABLE ALWAYS");
                break;
            case 'R':
                appendPQExpBuffer(query, "ENABLE REPLICA");
                break;
            default:
                appendPQExpBuffer(query, "ENABLE");
                break;
        }
        appendPQExpBuffer(query, " TRIGGER %s;\n",
                          fmtId(tginfo->dobj.name));
    }

    appendPQExpBuffer(labelq, "TRIGGER %s ",
                      fmtId(tginfo->dobj.name));
    appendPQExpBuffer(labelq, "ON %s",
                      fmtId(tbinfo->dobj.name));

    ArchiveEntry(fout, tginfo->dobj.catId, tginfo->dobj.dumpId,
                 tginfo->dobj.name,
                 tbinfo->dobj.namespace->dobj.name,
                 NULL,
                 tbinfo->rolname, false,
                 "TRIGGER", SECTION_POST_DATA,
                 query->data, delqry->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    dumpComment(fout, labelq->data,
                tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
                tginfo->dobj.catId, 0, tginfo->dobj.dumpId);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(delqry);
    destroyPQExpBuffer(labelq);
}

static void dumpTSConfig ( Archive fout,
TSConfigInfo cfginfo 
) [static]

Definition at line 11836 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, _cfgInfo::cfgparser, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _cfgInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQuery(), ExecuteSqlQueryForSingleRow(), fmtId(), i, _dumpableObject::name, NULL, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), resetPQExpBuffer(), _cfgInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PQExpBuffer query;
    PGresult   *res;
    char       *nspname;
    char       *prsname;
    int         ntups,
                i;
    int         i_tokenname;
    int         i_dictname;

    /* Skip if not to be dumped */
    if (!cfginfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();
    query = createPQExpBuffer();

    /* Fetch name and namespace of the config's parser */
    selectSourceSchema(fout, "pg_catalog");
    appendPQExpBuffer(query, "SELECT nspname, prsname "
                      "FROM pg_ts_parser p, pg_namespace n "
                      "WHERE p.oid = '%u' AND n.oid = prsnamespace",
                      cfginfo->cfgparser);
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
    nspname = PQgetvalue(res, 0, 0);
    prsname = PQgetvalue(res, 0, 1);

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, cfginfo->dobj.namespace->dobj.name);

    appendPQExpBuffer(q, "CREATE TEXT SEARCH CONFIGURATION %s (\n",
                      fmtId(cfginfo->dobj.name));

    appendPQExpBuffer(q, "    PARSER = ");
    if (strcmp(nspname, cfginfo->dobj.namespace->dobj.name) != 0)
        appendPQExpBuffer(q, "%s.", fmtId(nspname));
    appendPQExpBuffer(q, "%s );\n", fmtId(prsname));

    PQclear(res);

    resetPQExpBuffer(query);
    appendPQExpBuffer(query,
                      "SELECT \n"
                      "  ( SELECT alias FROM pg_catalog.ts_token_type('%u'::pg_catalog.oid) AS t \n"
                      "    WHERE t.tokid = m.maptokentype ) AS tokenname, \n"
                      "  m.mapdict::pg_catalog.regdictionary AS dictname \n"
                      "FROM pg_catalog.pg_ts_config_map AS m \n"
                      "WHERE m.mapcfg = '%u' \n"
                      "ORDER BY m.mapcfg, m.maptokentype, m.mapseqno",
                      cfginfo->cfgparser, cfginfo->dobj.catId.oid);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    ntups = PQntuples(res);

    i_tokenname = PQfnumber(res, "tokenname");
    i_dictname = PQfnumber(res, "dictname");

    for (i = 0; i < ntups; i++)
    {
        char       *tokenname = PQgetvalue(res, i, i_tokenname);
        char       *dictname = PQgetvalue(res, i, i_dictname);

        if (i == 0 ||
            strcmp(tokenname, PQgetvalue(res, i - 1, i_tokenname)) != 0)
        {
            /* starting a new token type, so start a new command */
            if (i > 0)
                appendPQExpBuffer(q, ";\n");
            appendPQExpBuffer(q, "\nALTER TEXT SEARCH CONFIGURATION %s\n",
                              fmtId(cfginfo->dobj.name));
            /* tokenname needs quoting, dictname does NOT */
            appendPQExpBuffer(q, "    ADD MAPPING FOR %s WITH %s",
                              fmtId(tokenname), dictname);
        }
        else
            appendPQExpBuffer(q, ", %s", dictname);
    }

    if (ntups > 0)
        appendPQExpBuffer(q, ";\n");

    PQclear(res);

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP TEXT SEARCH CONFIGURATION %s",
                      fmtId(cfginfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s;\n",
                      fmtId(cfginfo->dobj.name));

    appendPQExpBuffer(labelq, "TEXT SEARCH CONFIGURATION %s",
                      fmtId(cfginfo->dobj.name));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &cfginfo->dobj, labelq->data);

    ArchiveEntry(fout, cfginfo->dobj.catId, cfginfo->dobj.dumpId,
                 cfginfo->dobj.name,
                 cfginfo->dobj.namespace->dobj.name,
                 NULL,
                 cfginfo->rolname,
                 false, "TEXT SEARCH CONFIGURATION", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Configuration Comments */
    dumpComment(fout, labelq->data,
                NULL, cfginfo->rolname,
                cfginfo->dobj.catId, 0, cfginfo->dobj.dumpId);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);
}

static void dumpTSDictionary ( Archive fout,
TSDictInfo dictinfo 
) [static]

Definition at line 11683 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _dictInfo::dictinitoption, _dictInfo::dicttemplate, _dictInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, ExecuteSqlQueryForSingleRow(), fmtId(), _dumpableObject::name, NULL, PQclear(), PQgetvalue(), _dictInfo::rolname, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;
    PQExpBuffer query;
    PGresult   *res;
    char       *nspname;
    char       *tmplname;

    /* Skip if not to be dumped */
    if (!dictinfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();
    query = createPQExpBuffer();

    /* Fetch name and namespace of the dictionary's template */
    selectSourceSchema(fout, "pg_catalog");
    appendPQExpBuffer(query, "SELECT nspname, tmplname "
                      "FROM pg_ts_template p, pg_namespace n "
                      "WHERE p.oid = '%u' AND n.oid = tmplnamespace",
                      dictinfo->dicttemplate);
    res = ExecuteSqlQueryForSingleRow(fout, query->data);
    nspname = PQgetvalue(res, 0, 0);
    tmplname = PQgetvalue(res, 0, 1);

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, dictinfo->dobj.namespace->dobj.name);

    appendPQExpBuffer(q, "CREATE TEXT SEARCH DICTIONARY %s (\n",
                      fmtId(dictinfo->dobj.name));

    appendPQExpBuffer(q, "    TEMPLATE = ");
    if (strcmp(nspname, dictinfo->dobj.namespace->dobj.name) != 0)
        appendPQExpBuffer(q, "%s.", fmtId(nspname));
    appendPQExpBuffer(q, "%s", fmtId(tmplname));

    PQclear(res);

    /* the dictinitoption can be dumped straight into the command */
    if (dictinfo->dictinitoption)
        appendPQExpBuffer(q, ",\n    %s", dictinfo->dictinitoption);

    appendPQExpBuffer(q, " );\n");

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP TEXT SEARCH DICTIONARY %s",
                      fmtId(dictinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s;\n",
                      fmtId(dictinfo->dobj.name));

    appendPQExpBuffer(labelq, "TEXT SEARCH DICTIONARY %s",
                      fmtId(dictinfo->dobj.name));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &dictinfo->dobj, labelq->data);

    ArchiveEntry(fout, dictinfo->dobj.catId, dictinfo->dobj.dumpId,
                 dictinfo->dobj.name,
                 dictinfo->dobj.namespace->dobj.name,
                 NULL,
                 dictinfo->rolname,
                 false, "TEXT SEARCH DICTIONARY", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Dictionary Comments */
    dumpComment(fout, labelq->data,
                NULL, dictinfo->rolname,
                dictinfo->dobj.catId, 0, dictinfo->dobj.dumpId);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
    destroyPQExpBuffer(query);
}

static void dumpTSParser ( Archive fout,
TSParserInfo prsinfo 
) [static]

Definition at line 11612 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, convertTSFunction(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _prsInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, fmtId(), InvalidOid, _dumpableObject::name, NULL, _prsInfo::prsend, _prsInfo::prsheadline, _prsInfo::prslextype, _prsInfo::prsstart, _prsInfo::prstoken, SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;

    /* Skip if not to be dumped */
    if (!prsinfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, prsinfo->dobj.namespace->dobj.name);

    appendPQExpBuffer(q, "CREATE TEXT SEARCH PARSER %s (\n",
                      fmtId(prsinfo->dobj.name));

    appendPQExpBuffer(q, "    START = %s,\n",
                      convertTSFunction(fout, prsinfo->prsstart));
    appendPQExpBuffer(q, "    GETTOKEN = %s,\n",
                      convertTSFunction(fout, prsinfo->prstoken));
    appendPQExpBuffer(q, "    END = %s,\n",
                      convertTSFunction(fout, prsinfo->prsend));
    if (prsinfo->prsheadline != InvalidOid)
        appendPQExpBuffer(q, "    HEADLINE = %s,\n",
                          convertTSFunction(fout, prsinfo->prsheadline));
    appendPQExpBuffer(q, "    LEXTYPES = %s );\n",
                      convertTSFunction(fout, prsinfo->prslextype));

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP TEXT SEARCH PARSER %s",
                      fmtId(prsinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s;\n",
                      fmtId(prsinfo->dobj.name));

    appendPQExpBuffer(labelq, "TEXT SEARCH PARSER %s",
                      fmtId(prsinfo->dobj.name));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &prsinfo->dobj, labelq->data);

    ArchiveEntry(fout, prsinfo->dobj.catId, prsinfo->dobj.dumpId,
                 prsinfo->dobj.name,
                 prsinfo->dobj.namespace->dobj.name,
                 NULL,
                 "",
                 false, "TEXT SEARCH PARSER", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Parser Comments */
    dumpComment(fout, labelq->data,
                NULL, "",
                prsinfo->dobj.catId, 0, prsinfo->dobj.dumpId);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpTSTemplate ( Archive fout,
TSTemplateInfo tmplinfo 
) [static]

Definition at line 11771 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), binary_upgrade, binary_upgrade_extension_member(), _dumpableObject::catId, convertTSFunction(), createPQExpBuffer(), PQExpBufferData::data, dataOnly, destroyPQExpBuffer(), _tmplInfo::dobj, _dumpableObject::dump, dumpComment(), _dumpableObject::dumpId, fmtId(), InvalidOid, _dumpableObject::name, NULL, SECTION_PRE_DATA, selectSourceSchema(), _tmplInfo::tmplinit, and _tmplInfo::tmpllexize.

Referenced by dumpDumpableObject().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer labelq;

    /* Skip if not to be dumped */
    if (!tmplinfo->dobj.dump || dataOnly)
        return;

    q = createPQExpBuffer();
    delq = createPQExpBuffer();
    labelq = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, tmplinfo->dobj.namespace->dobj.name);

    appendPQExpBuffer(q, "CREATE TEXT SEARCH TEMPLATE %s (\n",
                      fmtId(tmplinfo->dobj.name));

    if (tmplinfo->tmplinit != InvalidOid)
        appendPQExpBuffer(q, "    INIT = %s,\n",
                          convertTSFunction(fout, tmplinfo->tmplinit));
    appendPQExpBuffer(q, "    LEXIZE = %s );\n",
                      convertTSFunction(fout, tmplinfo->tmpllexize));

    /*
     * DROP must be fully qualified in case same name appears in pg_catalog
     */
    appendPQExpBuffer(delq, "DROP TEXT SEARCH TEMPLATE %s",
                      fmtId(tmplinfo->dobj.namespace->dobj.name));
    appendPQExpBuffer(delq, ".%s;\n",
                      fmtId(tmplinfo->dobj.name));

    appendPQExpBuffer(labelq, "TEXT SEARCH TEMPLATE %s",
                      fmtId(tmplinfo->dobj.name));

    if (binary_upgrade)
        binary_upgrade_extension_member(q, &tmplinfo->dobj, labelq->data);

    ArchiveEntry(fout, tmplinfo->dobj.catId, tmplinfo->dobj.dumpId,
                 tmplinfo->dobj.name,
                 tmplinfo->dobj.namespace->dobj.name,
                 NULL,
                 "",
                 false, "TEXT SEARCH TEMPLATE", SECTION_PRE_DATA,
                 q->data, delq->data, NULL,
                 NULL, 0,
                 NULL, NULL);

    /* Dump Template Comments */
    dumpComment(fout, labelq->data,
                NULL, "",
                tmplinfo->dobj.catId, 0, tmplinfo->dobj.dumpId);

    destroyPQExpBuffer(q);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(labelq);
}

static void dumpType ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 7951 of file pg_dump.c.

References dataOnly, dumpBaseType(), dumpCompositeType(), dumpDomain(), dumpEnumType(), dumpRangeType(), NULL, TYPTYPE_BASE, TYPTYPE_COMPOSITE, TYPTYPE_DOMAIN, TYPTYPE_ENUM, TYPTYPE_RANGE, and write_msg().

Referenced by dumpDumpableObject().

{
    /* Skip if not to be dumped */
    if (!tyinfo->dobj.dump || dataOnly)
        return;

    /* Dump out in proper style */
    if (tyinfo->typtype == TYPTYPE_BASE)
        dumpBaseType(fout, tyinfo);
    else if (tyinfo->typtype == TYPTYPE_DOMAIN)
        dumpDomain(fout, tyinfo);
    else if (tyinfo->typtype == TYPTYPE_COMPOSITE)
        dumpCompositeType(fout, tyinfo);
    else if (tyinfo->typtype == TYPTYPE_ENUM)
        dumpEnumType(fout, tyinfo);
    else if (tyinfo->typtype == TYPTYPE_RANGE)
        dumpRangeType(fout, tyinfo);
    else
        write_msg(NULL, "WARNING: typtype of data type \"%s\" appears to be invalid\n",
                  tyinfo->dobj.name);
}

static void dumpUserMappings ( Archive fout,
const char *  servername,
const char *  namespace,
const char *  owner,
CatalogId  catalogId,
DumpId  dumpId 
) [static]

Definition at line 12148 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), createDumpId(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), fmtId(), i, NULL, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), resetPQExpBuffer(), SECTION_PRE_DATA, and selectSourceSchema().

Referenced by dumpForeignServer().

{
    PQExpBuffer q;
    PQExpBuffer delq;
    PQExpBuffer query;
    PQExpBuffer tag;
    PGresult   *res;
    int         ntups;
    int         i_usename;
    int         i_umoptions;
    int         i;

    q = createPQExpBuffer();
    tag = createPQExpBuffer();
    delq = createPQExpBuffer();
    query = createPQExpBuffer();

    /*
     * We read from the publicly accessible view pg_user_mappings, so as not
     * to fail if run by a non-superuser.  Note that the view will show
     * umoptions as null if the user hasn't got privileges for the associated
     * server; this means that pg_dump will dump such a mapping, but with no
     * OPTIONS clause.  A possible alternative is to skip such mappings
     * altogether, but it's not clear that that's an improvement.
     */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query,
                      "SELECT usename, "
                      "array_to_string(ARRAY("
                      "SELECT quote_ident(option_name) || ' ' || "
                      "quote_literal(option_value) "
                      "FROM pg_options_to_table(umoptions) "
                      "ORDER BY option_name"
                      "), E',\n    ') AS umoptions "
                      "FROM pg_user_mappings "
                      "WHERE srvid = '%u' "
                      "ORDER BY usename",
                      catalogId.oid);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    i_usename = PQfnumber(res, "usename");
    i_umoptions = PQfnumber(res, "umoptions");

    for (i = 0; i < ntups; i++)
    {
        char       *usename;
        char       *umoptions;

        usename = PQgetvalue(res, i, i_usename);
        umoptions = PQgetvalue(res, i, i_umoptions);

        resetPQExpBuffer(q);
        appendPQExpBuffer(q, "CREATE USER MAPPING FOR %s", fmtId(usename));
        appendPQExpBuffer(q, " SERVER %s", fmtId(servername));

        if (umoptions && strlen(umoptions) > 0)
            appendPQExpBuffer(q, " OPTIONS (\n    %s\n)", umoptions);

        appendPQExpBuffer(q, ";\n");

        resetPQExpBuffer(delq);
        appendPQExpBuffer(delq, "DROP USER MAPPING FOR %s", fmtId(usename));
        appendPQExpBuffer(delq, " SERVER %s;\n", fmtId(servername));

        resetPQExpBuffer(tag);
        appendPQExpBuffer(tag, "USER MAPPING %s SERVER %s",
                          usename, servername);

        ArchiveEntry(fout, nilCatalogId, createDumpId(),
                     tag->data,
                     namespace,
                     NULL,
                     owner, false,
                     "USER MAPPING", SECTION_PRE_DATA,
                     q->data, delq->data, NULL,
                     &dumpId, 1,
                     NULL, NULL);
    }

    PQclear(res);

    destroyPQExpBuffer(query);
    destroyPQExpBuffer(delq);
    destroyPQExpBuffer(q);
}

static PGresult * ExecuteSqlQueryForSingleRow ( Archive fout,
char *  query 
) [static]
static void expand_schema_name_patterns ( Archive fout,
SimpleStringList patterns,
SimpleOidList oids 
) [static]

Definition at line 1103 of file pg_dump.c.

References appendPQExpBuffer(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), exit_horribly(), GetConnection(), SimpleStringList::head, i, SimpleStringListCell::next, NULL, PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), processSQLNamePattern(), Archive::remoteVersion, simple_oid_list_append(), and SimpleStringListCell::val.

Referenced by main().

{
    PQExpBuffer query;
    PGresult   *res;
    SimpleStringListCell *cell;
    int         i;

    if (patterns->head == NULL)
        return;                 /* nothing to do */

    if (fout->remoteVersion < 70300)
        exit_horribly(NULL, "server version must be at least 7.3 to use schema selection switches\n");

    query = createPQExpBuffer();

    /*
     * We use UNION ALL rather than UNION; this might sometimes result in
     * duplicate entries in the OID list, but we don't care.
     */

    for (cell = patterns->head; cell; cell = cell->next)
    {
        if (cell != patterns->head)
            appendPQExpBuffer(query, "UNION ALL\n");
        appendPQExpBuffer(query,
                          "SELECT oid FROM pg_catalog.pg_namespace n\n");
        processSQLNamePattern(GetConnection(fout), query, cell->val, false,
                              false, NULL, "n.nspname", NULL, NULL);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    for (i = 0; i < PQntuples(res); i++)
    {
        simple_oid_list_append(oids, atooid(PQgetvalue(res, i, 0)));
    }

    PQclear(res);
    destroyPQExpBuffer(query);
}

static void expand_table_name_patterns ( Archive fout,
SimpleStringList patterns,
SimpleOidList oids 
) [static]

Definition at line 1151 of file pg_dump.c.

References appendPQExpBuffer(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), GetConnection(), SimpleStringList::head, i, SimpleStringListCell::next, NULL, PGRES_TUPLES_OK, PQclear(), PQgetvalue(), PQntuples(), processSQLNamePattern(), RELKIND_FOREIGN_TABLE, RELKIND_MATVIEW, RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW, simple_oid_list_append(), and SimpleStringListCell::val.

Referenced by main().

{
    PQExpBuffer query;
    PGresult   *res;
    SimpleStringListCell *cell;
    int         i;

    if (patterns->head == NULL)
        return;                 /* nothing to do */

    query = createPQExpBuffer();

    /*
     * We use UNION ALL rather than UNION; this might sometimes result in
     * duplicate entries in the OID list, but we don't care.
     */

    for (cell = patterns->head; cell; cell = cell->next)
    {
        if (cell != patterns->head)
            appendPQExpBuffer(query, "UNION ALL\n");
        appendPQExpBuffer(query,
                          "SELECT c.oid"
                          "\nFROM pg_catalog.pg_class c"
        "\n     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace"
                     "\nWHERE c.relkind in ('%c', '%c', '%c', '%c', '%c')\n",
                          RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW,
                          RELKIND_MATVIEW, RELKIND_FOREIGN_TABLE);
        processSQLNamePattern(GetConnection(fout), query, cell->val, true,
                              false, "n.nspname", "c.relname", NULL,
                              "pg_catalog.pg_table_is_visible(c.oid)");
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    for (i = 0; i < PQntuples(res); i++)
    {
        simple_oid_list_append(oids, atooid(PQgetvalue(res, i, 0)));
    }

    PQclear(res);
    destroyPQExpBuffer(query);
}

static int findComments ( Archive fout,
Oid  classoid,
Oid  objoid,
CommentItem **  items 
) [static]

Definition at line 7475 of file pg_dump.c.

References CommentItem::classoid, collectComments(), CommentItem::objoid, and Archive::remoteVersion.

Referenced by dumpComment(), dumpCompositeTypeColComments(), and dumpTableComment().

{
    /* static storage for table of comments */
    static CommentItem *comments = NULL;
    static int  ncomments = -1;

    CommentItem *middle = NULL;
    CommentItem *low;
    CommentItem *high;
    int         nmatch;

    /* Get comments if we didn't already */
    if (ncomments < 0)
        ncomments = collectComments(fout, &comments);

    /*
     * Pre-7.2, pg_description does not contain classoid, so collectComments
     * just stores a zero.  If there's a collision on object OID, well, you
     * get duplicate comments.
     */
    if (fout->remoteVersion < 70200)
        classoid = 0;

    /*
     * Do binary search to find some item matching the object.
     */
    low = &comments[0];
    high = &comments[ncomments - 1];
    while (low <= high)
    {
        middle = low + (high - low) / 2;

        if (classoid < middle->classoid)
            high = middle - 1;
        else if (classoid > middle->classoid)
            low = middle + 1;
        else if (objoid < middle->objoid)
            high = middle - 1;
        else if (objoid > middle->objoid)
            low = middle + 1;
        else
            break;              /* found a match */
    }

    if (low > high)             /* no matches */
    {
        *items = NULL;
        return 0;
    }

    /*
     * Now determine how many items match the object.  The search loop
     * invariant still holds: only items between low and high inclusive could
     * match.
     */
    nmatch = 1;
    while (middle > low)
    {
        if (classoid != middle[-1].classoid ||
            objoid != middle[-1].objoid)
            break;
        middle--;
        nmatch++;
    }

    *items = middle;

    middle += nmatch;
    while (middle <= high)
    {
        if (classoid != middle->classoid ||
            objoid != middle->objoid)
            break;
        middle++;
        nmatch++;
    }

    return nmatch;
}

static void findDumpableDependencies ( ArchiveHandle AH,
DumpableObject dobj,
DumpId **  dependencies,
int *  nDeps,
int *  allocDeps 
) [static]

Definition at line 14994 of file pg_dump.c.

References _dumpableObject::dependencies, DO_POST_DATA_BOUNDARY, DO_PRE_DATA_BOUNDARY, findObjectByDumpId(), i, _dumpableObject::nDeps, _dumpableObject::objType, pg_realloc(), and TocIDRequired().

Referenced by BuildArchiveDependencies().

{
    int         i;

    /*
     * Ignore section boundary objects: if we search through them, we'll
     * report lots of bogus dependencies.
     */
    if (dobj->objType == DO_PRE_DATA_BOUNDARY ||
        dobj->objType == DO_POST_DATA_BOUNDARY)
        return;

    for (i = 0; i < dobj->nDeps; i++)
    {
        DumpId      depid = dobj->dependencies[i];

        if (TocIDRequired(AH, depid) != 0)
        {
            /* Object will be dumped, so just reference it as a dependency */
            if (*nDeps >= *allocDeps)
            {
                *allocDeps *= 2;
                *dependencies = (DumpId *) pg_realloc(*dependencies,
                                                *allocDeps * sizeof(DumpId));
            }
            (*dependencies)[*nDeps] = depid;
            (*nDeps)++;
        }
        else
        {
            /*
             * Object will not be dumped, so recursively consider its deps. We
             * rely on the assumption that sortDumpableObjects already broke
             * any dependency loops, else we might recurse infinitely.
             */
            DumpableObject *otherdobj = findObjectByDumpId(depid);

            if (otherdobj)
                findDumpableDependencies(AH, otherdobj,
                                         dependencies, nDeps, allocDeps);
        }
    }
}

static Oid findLastBuiltinOid_V70 ( Archive fout  )  [static]

Definition at line 13825 of file pg_dump.c.

References atooid, ExecuteSqlQueryForSingleRow(), PQclear(), PQfnumber(), and PQgetvalue().

Referenced by main().

{
    PGresult   *res;
    int         last_oid;

    res = ExecuteSqlQueryForSingleRow(fout,
                    "SELECT oid FROM pg_class WHERE relname = 'pg_indexes'");
    last_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "oid")));
    PQclear(res);
    return last_oid;
}

static Oid findLastBuiltinOid_V71 ( Archive fout,
const char *  dbname 
) [static]

Definition at line 13799 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralAH, atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), PQclear(), PQfnumber(), PQgetvalue(), and resetPQExpBuffer().

Referenced by main().

{
    PGresult   *res;
    Oid         last_oid;
    PQExpBuffer query = createPQExpBuffer();

    resetPQExpBuffer(query);
    appendPQExpBuffer(query, "SELECT datlastsysoid from pg_database where datname = ");
    appendStringLiteralAH(query, dbname, fout);

    res = ExecuteSqlQueryForSingleRow(fout, query->data);
    last_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "datlastsysoid")));
    PQclear(res);
    destroyPQExpBuffer(query);
    return last_oid;
}

static NamespaceInfo * findNamespace ( Archive fout,
Oid  nsoid,
Oid  objoid 
) [static]

Definition at line 2989 of file pg_dump.c.

References exit_horribly(), findNamespaceByOid(), g_last_builtin_oid, i, NULL, and Archive::remoteVersion.

Referenced by getAggregates(), getCollations(), getConversions(), getDefaultACLs(), getFuncs(), getOpclasses(), getOperators(), getOpfamilies(), getTables(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), and getTypes().

{
    NamespaceInfo *nsinfo;

    if (fout->remoteVersion >= 70300)
    {
        nsinfo = findNamespaceByOid(nsoid);
    }
    else
    {
        /* This code depends on the dummy objects set up by getNamespaces. */
        Oid         i;

        if (objoid > g_last_builtin_oid)
            i = 0;              /* user object */
        else
            i = 1;              /* system object */
        nsinfo = findNamespaceByOid(i);
    }

    if (nsinfo == NULL)
        exit_horribly(NULL, "schema with OID %u does not exist\n", nsoid);

    return nsinfo;
}

static int findSecLabels ( Archive fout,
Oid  classoid,
Oid  objoid,
SecLabelItem **  items 
) [static]

Definition at line 12523 of file pg_dump.c.

References SecLabelItem::classoid, collectSecLabels(), and SecLabelItem::objoid.

Referenced by dumpSecLabel(), and dumpTableSecLabel().

{
    /* static storage for table of security labels */
    static SecLabelItem *labels = NULL;
    static int  nlabels = -1;

    SecLabelItem *middle = NULL;
    SecLabelItem *low;
    SecLabelItem *high;
    int         nmatch;

    /* Get security labels if we didn't already */
    if (nlabels < 0)
        nlabels = collectSecLabels(fout, &labels);

    if (nlabels <= 0)           /* no labels, so no match is possible */
    {
        *items = NULL;
        return 0;
    }

    /*
     * Do binary search to find some item matching the object.
     */
    low = &labels[0];
    high = &labels[nlabels - 1];
    while (low <= high)
    {
        middle = low + (high - low) / 2;

        if (classoid < middle->classoid)
            high = middle - 1;
        else if (classoid > middle->classoid)
            low = middle + 1;
        else if (objoid < middle->objoid)
            high = middle - 1;
        else if (objoid > middle->objoid)
            low = middle + 1;
        else
            break;              /* found a match */
    }

    if (low > high)             /* no matches */
    {
        *items = NULL;
        return 0;
    }

    /*
     * Now determine how many items match the object.  The search loop
     * invariant still holds: only items between low and high inclusive could
     * match.
     */
    nmatch = 1;
    while (middle > low)
    {
        if (classoid != middle[-1].classoid ||
            objoid != middle[-1].objoid)
            break;
        middle--;
        nmatch++;
    }

    *items = middle;

    middle += nmatch;
    while (middle <= high)
    {
        if (classoid != middle->classoid ||
            objoid != middle->objoid)
            break;
        middle++;
        nmatch++;
    }

    return nmatch;
}

static const char * fmtCopyColumnList ( const TableInfo ti,
PQExpBuffer  buffer 
) [static]

Definition at line 15219 of file pg_dump.c.

References appendPQExpBuffer(), _tableInfo::attisdropped, _tableInfo::attnames, PQExpBufferData::data, fmtId(), i, and _tableInfo::numatts.

Referenced by dumpTableData(), and dumpTableData_copy().

{
    int         numatts = ti->numatts;
    char      **attnames = ti->attnames;
    bool       *attisdropped = ti->attisdropped;
    bool        needComma;
    int         i;

    appendPQExpBuffer(buffer, "(");
    needComma = false;
    for (i = 0; i < numatts; i++)
    {
        if (attisdropped[i])
            continue;
        if (needComma)
            appendPQExpBuffer(buffer, ", ");
        appendPQExpBuffer(buffer, "%s", fmtId(attnames[i]));
        needComma = true;
    }

    if (!needComma)
        return "";              /* no undropped columns */

    appendPQExpBuffer(buffer, ")");
    return buffer->data;
}

static char* format_aggregate_signature ( AggInfo agginfo,
Archive fout,
bool  honor_quotes 
) [static]

Definition at line 11353 of file pg_dump.c.

References _aggInfo::aggfn, appendPQExpBuffer(), _funcInfo::argtypes, buf, PQExpBufferData::data, _funcInfo::dobj, fmtId(), free, getFormattedTypeName(), initPQExpBuffer(), _dumpableObject::name, _funcInfo::nargs, and zeroAsOpaque.

Referenced by dumpAgg().

{
    PQExpBufferData buf;
    int         j;

    initPQExpBuffer(&buf);
    if (honor_quotes)
        appendPQExpBuffer(&buf, "%s",
                          fmtId(agginfo->aggfn.dobj.name));
    else
        appendPQExpBuffer(&buf, "%s", agginfo->aggfn.dobj.name);

    if (agginfo->aggfn.nargs == 0)
        appendPQExpBuffer(&buf, "(*)");
    else
    {
        appendPQExpBuffer(&buf, "(");
        for (j = 0; j < agginfo->aggfn.nargs; j++)
        {
            char       *typname;

            typname = getFormattedTypeName(fout, agginfo->aggfn.argtypes[j],
                                           zeroAsOpaque);

            appendPQExpBuffer(&buf, "%s%s",
                              (j > 0) ? ", " : "",
                              typname);
            free(typname);
        }
        appendPQExpBuffer(&buf, ")");
    }
    return buf.data;
}

static char * format_function_arguments ( FuncInfo finfo,
char *  funcargs 
) [static]

Definition at line 9362 of file pg_dump.c.

References appendPQExpBuffer(), PQExpBufferData::data, _funcInfo::dobj, fmtId(), initPQExpBuffer(), and _dumpableObject::name.

Referenced by dumpFunc().

{
    PQExpBufferData fn;

    initPQExpBuffer(&fn);
    appendPQExpBuffer(&fn, "%s(%s)", fmtId(finfo->dobj.name), funcargs);
    return fn.data;
}

static char * format_function_arguments_old ( Archive fout,
FuncInfo finfo,
int  nallargs,
char **  allargtypes,
char **  argmodes,
char **  argnames 
) [static]

Definition at line 9383 of file pg_dump.c.

References appendPQExpBuffer(), _funcInfo::argtypes, atooid, PQExpBufferData::data, _funcInfo::dobj, fmtId(), free, getFormattedTypeName(), initPQExpBuffer(), _dumpableObject::name, NULL, PROARGMODE_IN, PROARGMODE_INOUT, PROARGMODE_OUT, write_msg(), and zeroAsOpaque.

Referenced by dumpFunc().

{
    PQExpBufferData fn;
    int         j;

    initPQExpBuffer(&fn);
    appendPQExpBuffer(&fn, "%s(", fmtId(finfo->dobj.name));
    for (j = 0; j < nallargs; j++)
    {
        Oid         typid;
        char       *typname;
        const char *argmode;
        const char *argname;

        typid = allargtypes ? atooid(allargtypes[j]) : finfo->argtypes[j];
        typname = getFormattedTypeName(fout, typid, zeroAsOpaque);

        if (argmodes)
        {
            switch (argmodes[j][0])
            {
                case PROARGMODE_IN:
                    argmode = "";
                    break;
                case PROARGMODE_OUT:
                    argmode = "OUT ";
                    break;
                case PROARGMODE_INOUT:
                    argmode = "INOUT ";
                    break;
                default:
                    write_msg(NULL, "WARNING: bogus value in proargmodes array\n");
                    argmode = "";
                    break;
            }
        }
        else
            argmode = "";

        argname = argnames ? argnames[j] : (char *) NULL;
        if (argname && argname[0] == '\0')
            argname = NULL;

        appendPQExpBuffer(&fn, "%s%s%s%s%s",
                          (j > 0) ? ", " : "",
                          argmode,
                          argname ? fmtId(argname) : "",
                          argname ? " " : "",
                          typname);
        free(typname);
    }
    appendPQExpBuffer(&fn, ")");
    return fn.data;
}

static char * format_function_signature ( Archive fout,
FuncInfo finfo,
bool  honor_quotes 
) [static]

Definition at line 9453 of file pg_dump.c.

References appendPQExpBuffer(), _funcInfo::argtypes, PQExpBufferData::data, _funcInfo::dobj, fmtId(), free, getFormattedTypeName(), initPQExpBuffer(), _dumpableObject::name, _funcInfo::nargs, and zeroAsOpaque.

Referenced by dumpAgg(), dumpCast(), and dumpFunc().

{
    PQExpBufferData fn;
    int         j;

    initPQExpBuffer(&fn);
    if (honor_quotes)
        appendPQExpBuffer(&fn, "%s(", fmtId(finfo->dobj.name));
    else
        appendPQExpBuffer(&fn, "%s(", finfo->dobj.name);
    for (j = 0; j < finfo->nargs; j++)
    {
        char       *typname;

        typname = getFormattedTypeName(fout, finfo->argtypes[j],
                                       zeroAsOpaque);

        appendPQExpBuffer(&fn, "%s%s",
                          (j > 0) ? ", " : "",
                          typname);
        free(typname);
    }
    appendPQExpBuffer(&fn, ")");
    return fn.data;
}

static char * get_synchronized_snapshot ( Archive fout  )  [static]

Definition at line 1051 of file pg_dump.c.

References ExecuteSqlQueryForSingleRow(), PQclear(), and PQgetvalue().

Referenced by setup_connection().

{
    char       *query = "SELECT pg_export_snapshot()";
    char       *result;
    PGresult   *res;

    res = ExecuteSqlQueryForSingleRow(fout, query);
    result = strdup(PQgetvalue(res, 0, 0));
    PQclear(res);

    return result;
}

AggInfo* getAggregates ( Archive fout,
int *  numAggs 
)

Definition at line 3836 of file pg_dump.c.

References _aggInfo::aggfn, appendPQExpBuffer(), _funcInfo::argtypes, AssignDumpId(), atooid, binary_upgrade, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _funcInfo::dobj, ExecuteSqlQuery(), findNamespace(), g_last_builtin_oid, i, _funcInfo::lang, _dumpableObject::name, _funcInfo::nargs, NULL, _dumpableObject::objType, CatalogId::oid, parseOidArray(), pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _funcInfo::proacl, _funcInfo::proiargs, _funcInfo::prorettype, Archive::remoteVersion, _funcInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    AggInfo    *agginfo;
    int         i_tableoid;
    int         i_oid;
    int         i_aggname;
    int         i_aggnamespace;
    int         i_pronargs;
    int         i_proargtypes;
    int         i_rolname;
    int         i_aggacl;
    int         i_proiargs;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /*
     * Find all user-defined aggregates.  See comment in getFuncs() for the
     * rationale behind the filtering logic.
     */

    if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, proname AS aggname, "
                          "pronamespace AS aggnamespace, "
                          "pronargs, proargtypes, "
            "pg_catalog.pg_get_function_identity_arguments(oid) AS proiargs,"
                          "(%s proowner) AS rolname, "
                          "proacl AS aggacl "
                          "FROM pg_proc p "
                          "WHERE proisagg AND ("
                          "pronamespace != "
                          "(SELECT oid FROM pg_namespace "
                          "WHERE nspname = 'pg_catalog')",
                          username_subquery);
        if (binary_upgrade && fout->remoteVersion >= 90100)
            appendPQExpBuffer(query,
                              " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
                              "classid = 'pg_proc'::regclass AND "
                              "objid = p.oid AND "
                              "refclassid = 'pg_extension'::regclass AND "
                              "deptype = 'e')");
        appendPQExpBuffer(query, ")");
    }
    else if (fout->remoteVersion >= 80200)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, proname AS aggname, "
                          "pronamespace AS aggnamespace, "
                          "pronargs, proargtypes, "
                          "NULL::text AS proiargs,"
                          "(%s proowner) AS rolname, "
                          "proacl AS aggacl "
                          "FROM pg_proc p "
                          "WHERE proisagg AND ("
                          "pronamespace != "
                          "(SELECT oid FROM pg_namespace "
                          "WHERE nspname = 'pg_catalog'))",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, proname AS aggname, "
                          "pronamespace AS aggnamespace, "
                          "CASE WHEN proargtypes[0] = 'pg_catalog.\"any\"'::pg_catalog.regtype THEN 0 ELSE 1 END AS pronargs, "
                          "proargtypes, "
                          "NULL::text AS proiargs, "
                          "(%s proowner) AS rolname, "
                          "proacl AS aggacl "
                          "FROM pg_proc "
                          "WHERE proisagg "
                          "AND pronamespace != "
               "(SELECT oid FROM pg_namespace WHERE nspname = 'pg_catalog')",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, aggname, "
                          "0::oid AS aggnamespace, "
                  "CASE WHEN aggbasetype = 0 THEN 0 ELSE 1 END AS pronargs, "
                          "aggbasetype AS proargtypes, "
                          "NULL::text AS proiargs, "
                          "(%s aggowner) AS rolname, "
                          "'{=X}' AS aggacl "
                          "FROM pg_aggregate "
                          "where oid > '%u'::oid",
                          username_subquery,
                          g_last_builtin_oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT "
                          "(SELECT oid FROM pg_class WHERE relname = 'pg_aggregate') AS tableoid, "
                          "oid, aggname, "
                          "0::oid AS aggnamespace, "
                  "CASE WHEN aggbasetype = 0 THEN 0 ELSE 1 END AS pronargs, "
                          "aggbasetype AS proargtypes, "
                          "NULL::text AS proiargs, "
                          "(%s aggowner) AS rolname, "
                          "'{=X}' AS aggacl "
                          "FROM pg_aggregate "
                          "where oid > '%u'::oid",
                          username_subquery,
                          g_last_builtin_oid);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numAggs = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_aggname = PQfnumber(res, "aggname");
    i_aggnamespace = PQfnumber(res, "aggnamespace");
    i_pronargs = PQfnumber(res, "pronargs");
    i_proargtypes = PQfnumber(res, "proargtypes");
    i_rolname = PQfnumber(res, "rolname");
    i_aggacl = PQfnumber(res, "aggacl");
    i_proiargs = PQfnumber(res, "proiargs");

    for (i = 0; i < ntups; i++)
    {
        agginfo[i].aggfn.dobj.objType = DO_AGG;
        agginfo[i].aggfn.dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        agginfo[i].aggfn.dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&agginfo[i].aggfn.dobj);
        agginfo[i].aggfn.dobj.name = pg_strdup(PQgetvalue(res, i, i_aggname));
        agginfo[i].aggfn.dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_aggnamespace)),
                          agginfo[i].aggfn.dobj.catId.oid);
        agginfo[i].aggfn.rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        if (strlen(agginfo[i].aggfn.rolname) == 0)
            write_msg(NULL, "WARNING: owner of aggregate function \"%s\" appears to be invalid\n",
                      agginfo[i].aggfn.dobj.name);
        agginfo[i].aggfn.lang = InvalidOid;     /* not currently interesting */
        agginfo[i].aggfn.prorettype = InvalidOid;       /* not saved */
        agginfo[i].aggfn.proacl = pg_strdup(PQgetvalue(res, i, i_aggacl));
        agginfo[i].aggfn.proiargs = pg_strdup(PQgetvalue(res, i, i_proiargs));
        agginfo[i].aggfn.nargs = atoi(PQgetvalue(res, i, i_pronargs));
        if (agginfo[i].aggfn.nargs == 0)
            agginfo[i].aggfn.argtypes = NULL;
        else
        {
            agginfo[i].aggfn.argtypes = (Oid *) pg_malloc(agginfo[i].aggfn.nargs * sizeof(Oid));
            if (fout->remoteVersion >= 70300)
                parseOidArray(PQgetvalue(res, i, i_proargtypes),
                              agginfo[i].aggfn.argtypes,
                              agginfo[i].aggfn.nargs);
            else
                /* it's just aggbasetype */
                agginfo[i].aggfn.argtypes[0] = atooid(PQgetvalue(res, i, i_proargtypes));
        }

        /* Decide whether we want to dump it */
        selectDumpableObject(&(agginfo[i].aggfn.dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return agginfo;
}

static const char * getAttrName ( int  attrnum,
TableInfo tblInfo 
) [static]

Definition at line 13435 of file pg_dump.c.

References _tableInfo::attnames, _tableInfo::dobj, exit_horribly(), MaxCommandIdAttributeNumber, MaxTransactionIdAttributeNumber, MinCommandIdAttributeNumber, MinTransactionIdAttributeNumber, _dumpableObject::name, NULL, ObjectIdAttributeNumber, SelfItemPointerAttributeNumber, and TableOidAttributeNumber.

Referenced by dumpConstraint(), and dumpTableSecLabel().

{
    if (attrnum > 0 && attrnum <= tblInfo->numatts)
        return tblInfo->attnames[attrnum - 1];
    switch (attrnum)
    {
        case SelfItemPointerAttributeNumber:
            return "ctid";
        case ObjectIdAttributeNumber:
            return "oid";
        case MinTransactionIdAttributeNumber:
            return "xmin";
        case MinCommandIdAttributeNumber:
            return "cmin";
        case MaxTransactionIdAttributeNumber:
            return "xmax";
        case MaxCommandIdAttributeNumber:
            return "cmax";
        case TableOidAttributeNumber:
            return "tableoid";
    }
    exit_horribly(NULL, "invalid column number %d for table \"%s\"\n",
                  attrnum, tblInfo->dobj.name);
    return NULL;                /* keep compiler quiet */
}

static void getBlobs ( Archive fout  )  [static]

Definition at line 2481 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _blobInfo::blobacl, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _blobInfo::dobj, ExecuteSqlQuery(), g_verbose, i, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQgetisnull(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _blobInfo::rolname, selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by main().

{
    PQExpBuffer blobQry = createPQExpBuffer();
    BlobInfo   *binfo;
    DumpableObject *bdata;
    PGresult   *res;
    int         ntups;
    int         i;

    /* Verbose message */
    if (g_verbose)
        write_msg(NULL, "reading large objects\n");

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /* Fetch BLOB OIDs, and owner/ACL data if >= 9.0 */
    if (fout->remoteVersion >= 90000)
        appendPQExpBuffer(blobQry,
                          "SELECT oid, (%s lomowner) AS rolname, lomacl"
                          " FROM pg_largeobject_metadata",
                          username_subquery);
    else if (fout->remoteVersion >= 70100)
        appendPQExpBuffer(blobQry,
                          "SELECT DISTINCT loid, NULL::oid, NULL::oid"
                          " FROM pg_largeobject");
    else
        appendPQExpBuffer(blobQry,
                          "SELECT oid, NULL::oid, NULL::oid"
                          " FROM pg_class WHERE relkind = 'l'");

    res = ExecuteSqlQuery(fout, blobQry->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    if (ntups > 0)
    {
        /*
         * Each large object has its own BLOB archive entry.
         */
        binfo = (BlobInfo *) pg_malloc(ntups * sizeof(BlobInfo));

        for (i = 0; i < ntups; i++)
        {
            binfo[i].dobj.objType = DO_BLOB;
            binfo[i].dobj.catId.tableoid = LargeObjectRelationId;
            binfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, 0));
            AssignDumpId(&binfo[i].dobj);

            binfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, 0));
            if (!PQgetisnull(res, i, 1))
                binfo[i].rolname = pg_strdup(PQgetvalue(res, i, 1));
            else
                binfo[i].rolname = "";
            if (!PQgetisnull(res, i, 2))
                binfo[i].blobacl = pg_strdup(PQgetvalue(res, i, 2));
            else
                binfo[i].blobacl = NULL;
        }

        /*
         * If we have any large objects, a "BLOBS" archive entry is needed.
         * This is just a placeholder for sorting; it carries no data now.
         */
        bdata = (DumpableObject *) pg_malloc(sizeof(DumpableObject));
        bdata->objType = DO_BLOB_DATA;
        bdata->catId = nilCatalogId;
        AssignDumpId(bdata);
        bdata->name = pg_strdup("BLOBS");
    }

    PQclear(res);
    destroyPQExpBuffer(blobQry);
}

CastInfo* getCasts ( Archive fout,
int *  numCasts 
)

Definition at line 5988 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), AssignDumpId(), atooid, _castInfo::castcontext, _castInfo::castfunc, _castInfo::castmethod, _castInfo::castsource, _castInfo::casttarget, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _funcInfo::dobj, _castInfo::dobj, _dumpableObject::dumpId, ExecuteSqlQuery(), findFuncByOid(), findTypeByOid(), i, initPQExpBuffer(), _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, OidIsValid, pg_malloc(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectSourceSchema(), and CatalogId::tableoid.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    CastInfo   *castinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_castsource;
    int         i_casttarget;
    int         i_castfunc;
    int         i_castcontext;
    int         i_castmethod;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, "
                          "castsource, casttarget, castfunc, castcontext, "
                          "castmethod "
                          "FROM pg_cast ORDER BY 3,4");
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, "
                          "castsource, casttarget, castfunc, castcontext, "
                "CASE WHEN castfunc = 0 THEN 'b' ELSE 'f' END AS castmethod "
                          "FROM pg_cast ORDER BY 3,4");
    }
    else
    {
        appendPQExpBuffer(query, "SELECT 0 AS tableoid, p.oid, "
                          "t1.oid AS castsource, t2.oid AS casttarget, "
                          "p.oid AS castfunc, 'e' AS castcontext, "
                          "'f' AS castmethod "
                          "FROM pg_type t1, pg_type t2, pg_proc p "
                          "WHERE p.pronargs = 1 AND "
                          "p.proargtypes[0] = t1.oid AND "
                          "p.prorettype = t2.oid AND p.proname = t2.typname "
                          "ORDER BY 3,4");
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numCasts = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_castsource = PQfnumber(res, "castsource");
    i_casttarget = PQfnumber(res, "casttarget");
    i_castfunc = PQfnumber(res, "castfunc");
    i_castcontext = PQfnumber(res, "castcontext");
    i_castmethod = PQfnumber(res, "castmethod");

    for (i = 0; i < ntups; i++)
    {
        PQExpBufferData namebuf;
        TypeInfo   *sTypeInfo;
        TypeInfo   *tTypeInfo;

        castinfo[i].dobj.objType = DO_CAST;
        castinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        castinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&castinfo[i].dobj);
        castinfo[i].castsource = atooid(PQgetvalue(res, i, i_castsource));
        castinfo[i].casttarget = atooid(PQgetvalue(res, i, i_casttarget));
        castinfo[i].castfunc = atooid(PQgetvalue(res, i, i_castfunc));
        castinfo[i].castcontext = *(PQgetvalue(res, i, i_castcontext));
        castinfo[i].castmethod = *(PQgetvalue(res, i, i_castmethod));

        /*
         * Try to name cast as concatenation of typnames.  This is only used
         * for purposes of sorting.  If we fail to find either type, the name
         * will be an empty string.
         */
        initPQExpBuffer(&namebuf);
        sTypeInfo = findTypeByOid(castinfo[i].castsource);
        tTypeInfo = findTypeByOid(castinfo[i].casttarget);
        if (sTypeInfo && tTypeInfo)
            appendPQExpBuffer(&namebuf, "%s %s",
                              sTypeInfo->dobj.name, tTypeInfo->dobj.name);
        castinfo[i].dobj.name = namebuf.data;

        if (OidIsValid(castinfo[i].castfunc))
        {
            /*
             * We need to make a dependency to ensure the function will be
             * dumped first.  (In 7.3 and later the regular dependency
             * mechanism will handle this for us.)
             */
            FuncInfo   *funcInfo;

            funcInfo = findFuncByOid(castinfo[i].castfunc);
            if (funcInfo)
                addObjectDependency(&castinfo[i].dobj,
                                    funcInfo->dobj.dumpId);
        }
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return castinfo;
}

CollInfo* getCollations ( Archive fout,
int *  numCollations 
)

Definition at line 3490 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _collInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _collInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    CollInfo   *collinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_collname;
    int         i_collnamespace;
    int         i_rolname;

    /* Collations didn't exist pre-9.1 */
    if (fout->remoteVersion < 90100)
    {
        *numCollations = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /*
     * find all collations, including builtin collations; we filter out
     * system-defined collations at dump-out time.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, collname, "
                      "collnamespace, "
                      "(%s collowner) AS rolname "
                      "FROM pg_collation",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numCollations = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_collname = PQfnumber(res, "collname");
    i_collnamespace = PQfnumber(res, "collnamespace");
    i_rolname = PQfnumber(res, "rolname");

    for (i = 0; i < ntups; i++)
    {
        collinfo[i].dobj.objType = DO_COLLATION;
        collinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        collinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&collinfo[i].dobj);
        collinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_collname));
        collinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_collnamespace)),
                          collinfo[i].dobj.catId.oid);
        collinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(collinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return collinfo;
}

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

Definition at line 5191 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::confrelid, _constraintInfo::conindex, _constraintInfo::conislocal, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _tableInfo::dobj, _dumpableObject::dump, ExecuteSqlQuery(), g_verbose, _tableInfo::hastriggers, i, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, resetPQExpBuffer(), selectSourceSchema(), _constraintInfo::separate, CatalogId::tableoid, and write_msg().

Referenced by getSchemaData().

{
    int         i,
                j;
    ConstraintInfo *constrinfo;
    PQExpBuffer query;
    PGresult   *res;
    int         i_contableoid,
                i_conoid,
                i_conname,
                i_confrelid,
                i_condef;
    int         ntups;

    /* pg_constraint was created in 7.3, so nothing to do if older */
    if (fout->remoteVersion < 70300)
        return;

    query = createPQExpBuffer();

    for (i = 0; i < numTables; i++)
    {
        TableInfo  *tbinfo = &tblinfo[i];

        if (!tbinfo->hastriggers || !tbinfo->dobj.dump)
            continue;

        if (g_verbose)
            write_msg(NULL, "reading foreign key constraints for table \"%s\"\n",
                      tbinfo->dobj.name);

        /*
         * select table schema to ensure constraint expr is qualified if
         * needed
         */
        selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

        resetPQExpBuffer(query);
        appendPQExpBuffer(query,
                          "SELECT tableoid, oid, conname, confrelid, "
                          "pg_catalog.pg_get_constraintdef(oid) AS condef "
                          "FROM pg_catalog.pg_constraint "
                          "WHERE conrelid = '%u'::pg_catalog.oid "
                          "AND contype = 'f'",
                          tbinfo->dobj.catId.oid);
        res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

        ntups = PQntuples(res);

        i_contableoid = PQfnumber(res, "tableoid");
        i_conoid = PQfnumber(res, "oid");
        i_conname = PQfnumber(res, "conname");
        i_confrelid = PQfnumber(res, "confrelid");
        i_condef = PQfnumber(res, "condef");

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

        for (j = 0; j < ntups; j++)
        {
            constrinfo[j].dobj.objType = DO_FK_CONSTRAINT;
            constrinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid));
            constrinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid));
            AssignDumpId(&constrinfo[j].dobj);
            constrinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
            constrinfo[j].dobj.namespace = tbinfo->dobj.namespace;
            constrinfo[j].contable = tbinfo;
            constrinfo[j].condomain = NULL;
            constrinfo[j].contype = 'f';
            constrinfo[j].condef = pg_strdup(PQgetvalue(res, j, i_condef));
            constrinfo[j].confrelid = atooid(PQgetvalue(res, j, i_confrelid));
            constrinfo[j].conindex = 0;
            constrinfo[j].condeferrable = false;
            constrinfo[j].condeferred = false;
            constrinfo[j].conislocal = true;
            constrinfo[j].separate = true;
        }

        PQclear(res);
    }

    destroyPQExpBuffer(query);
}

ConvInfo* getConversions ( Archive fout,
int *  numConversions 
)

Definition at line 3571 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _convInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _convInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    ConvInfo   *convinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_conname;
    int         i_connamespace;
    int         i_rolname;

    /* Conversions didn't exist pre-7.3 */
    if (fout->remoteVersion < 70300)
    {
        *numConversions = 0;
        return NULL;
    }

    /*
     * find all conversions, including builtin conversions; we filter out
     * system-defined conversions at dump-out time.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, conname, "
                      "connamespace, "
                      "(%s conowner) AS rolname "
                      "FROM pg_conversion",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numConversions = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_conname = PQfnumber(res, "conname");
    i_connamespace = PQfnumber(res, "connamespace");
    i_rolname = PQfnumber(res, "rolname");

    for (i = 0; i < ntups; i++)
    {
        convinfo[i].dobj.objType = DO_CONVERSION;
        convinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        convinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&convinfo[i].dobj);
        convinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_conname));
        convinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_connamespace)),
                          convinfo[i].dobj.catId.oid);
        convinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(convinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return convinfo;
}

DefaultACLInfo* getDefaultACLs ( Archive fout,
int *  numDefaultACLs 
)

Definition at line 7224 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _defaultACLInfo::defaclacl, _defaultACLInfo::defaclobjtype, _defaultACLInfo::defaclrole, destroyPQExpBuffer(), _defaultACLInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, InvalidOid, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectDumpableDefaultACL(), selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    DefaultACLInfo *daclinfo;
    PQExpBuffer query;
    PGresult   *res;
    int         i_oid;
    int         i_tableoid;
    int         i_defaclrole;
    int         i_defaclnamespace;
    int         i_defaclobjtype;
    int         i_defaclacl;
    int         i,
                ntups;

    if (fout->remoteVersion < 90000)
    {
        *numDefaultACLs = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT oid, tableoid, "
                      "(%s defaclrole) AS defaclrole, "
                      "defaclnamespace, "
                      "defaclobjtype, "
                      "defaclacl "
                      "FROM pg_default_acl",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numDefaultACLs = ntups;

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

    i_oid = PQfnumber(res, "oid");
    i_tableoid = PQfnumber(res, "tableoid");
    i_defaclrole = PQfnumber(res, "defaclrole");
    i_defaclnamespace = PQfnumber(res, "defaclnamespace");
    i_defaclobjtype = PQfnumber(res, "defaclobjtype");
    i_defaclacl = PQfnumber(res, "defaclacl");

    for (i = 0; i < ntups; i++)
    {
        Oid         nspid = atooid(PQgetvalue(res, i, i_defaclnamespace));

        daclinfo[i].dobj.objType = DO_DEFAULT_ACL;
        daclinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        daclinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&daclinfo[i].dobj);
        /* cheesy ... is it worth coming up with a better object name? */
        daclinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_defaclobjtype));

        if (nspid != InvalidOid)
            daclinfo[i].dobj.namespace = findNamespace(fout, nspid,
                                                 daclinfo[i].dobj.catId.oid);
        else
            daclinfo[i].dobj.namespace = NULL;

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

        /* Decide whether we want to dump it */
        selectDumpableDefaultACL(&(daclinfo[i]));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return daclinfo;
}

static void getDependencies ( Archive fout  )  [static]

Definition at line 14697 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), DO_TABLE, DO_TYPE, _dumpableObject::dumpId, ExecuteSqlQuery(), findObjectByCatalogId(), g_verbose, i, NULL, _dumpableObject::objType, CatalogId::oid, PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectSourceSchema(), CatalogId::tableoid, and write_msg().

Referenced by main().

{
    PQExpBuffer query;
    PGresult   *res;
    int         ntups,
                i;
    int         i_classid,
                i_objid,
                i_refclassid,
                i_refobjid,
                i_deptype;
    DumpableObject *dobj,
               *refdobj;

    /* No dependency info available before 7.3 */
    if (fout->remoteVersion < 70300)
        return;

    if (g_verbose)
        write_msg(NULL, "reading dependency data\n");

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    query = createPQExpBuffer();

    /*
     * PIN dependencies aren't interesting, and EXTENSION dependencies were
     * already processed by getExtensionMembership.
     */
    appendPQExpBuffer(query, "SELECT "
                      "classid, objid, refclassid, refobjid, deptype "
                      "FROM pg_depend "
                      "WHERE deptype != 'p' AND deptype != 'e' "
                      "ORDER BY 1,2");

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    i_classid = PQfnumber(res, "classid");
    i_objid = PQfnumber(res, "objid");
    i_refclassid = PQfnumber(res, "refclassid");
    i_refobjid = PQfnumber(res, "refobjid");
    i_deptype = PQfnumber(res, "deptype");

    /*
     * Since we ordered the SELECT by referencing ID, we can expect that
     * multiple entries for the same object will appear together; this saves
     * on searches.
     */
    dobj = NULL;

    for (i = 0; i < ntups; i++)
    {
        CatalogId   objId;
        CatalogId   refobjId;
        char        deptype;

        objId.tableoid = atooid(PQgetvalue(res, i, i_classid));
        objId.oid = atooid(PQgetvalue(res, i, i_objid));
        refobjId.tableoid = atooid(PQgetvalue(res, i, i_refclassid));
        refobjId.oid = atooid(PQgetvalue(res, i, i_refobjid));
        deptype = *(PQgetvalue(res, i, i_deptype));

        if (dobj == NULL ||
            dobj->catId.tableoid != objId.tableoid ||
            dobj->catId.oid != objId.oid)
            dobj = findObjectByCatalogId(objId);

        /*
         * Failure to find objects mentioned in pg_depend is not unexpected,
         * since for example we don't collect info about TOAST tables.
         */
        if (dobj == NULL)
        {
#ifdef NOT_USED
            fprintf(stderr, "no referencing object %u %u\n",
                    objId.tableoid, objId.oid);
#endif
            continue;
        }

        refdobj = findObjectByCatalogId(refobjId);

        if (refdobj == NULL)
        {
#ifdef NOT_USED
            fprintf(stderr, "no referenced object %u %u\n",
                    refobjId.tableoid, refobjId.oid);
#endif
            continue;
        }

        /*
         * Ordinarily, table rowtypes have implicit dependencies on their
         * tables.  However, for a composite type the implicit dependency goes
         * the other way in pg_depend; which is the right thing for DROP but
         * it doesn't produce the dependency ordering we need. So in that one
         * case, we reverse the direction of the dependency.
         */
        if (deptype == 'i' &&
            dobj->objType == DO_TABLE &&
            refdobj->objType == DO_TYPE)
            addObjectDependency(refdobj, dobj->dumpId);
        else
            /* normal case */
            addObjectDependency(dobj, refdobj->dumpId);
    }

    PQclear(res);

    destroyPQExpBuffer(query);
}

static void getDomainConstraints ( Archive fout,
TypeInfo tyinfo 
) [static]

Definition at line 5280 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::confrelid, _constraintInfo::conindex, _constraintInfo::conislocal, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _dumpableObject::dumpId, ExecuteSqlQuery(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectSourceSchema(), _constraintInfo::separate, and CatalogId::tableoid.

Referenced by getTypes().

{
    int         i;
    ConstraintInfo *constrinfo;
    PQExpBuffer query;
    PGresult   *res;
    int         i_tableoid,
                i_oid,
                i_conname,
                i_consrc;
    int         ntups;

    /* pg_constraint was created in 7.3, so nothing to do if older */
    if (fout->remoteVersion < 70300)
        return;

    /*
     * select appropriate schema to ensure names in constraint are properly
     * qualified
     */
    selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);

    query = createPQExpBuffer();

    if (fout->remoteVersion >= 90100)
        appendPQExpBuffer(query, "SELECT tableoid, oid, conname, "
                          "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
                          "convalidated "
                          "FROM pg_catalog.pg_constraint "
                          "WHERE contypid = '%u'::pg_catalog.oid "
                          "ORDER BY conname",
                          tyinfo->dobj.catId.oid);

    else if (fout->remoteVersion >= 70400)
        appendPQExpBuffer(query, "SELECT tableoid, oid, conname, "
                          "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
                          "true as convalidated "
                          "FROM pg_catalog.pg_constraint "
                          "WHERE contypid = '%u'::pg_catalog.oid "
                          "ORDER BY conname",
                          tyinfo->dobj.catId.oid);
    else
        appendPQExpBuffer(query, "SELECT tableoid, oid, conname, "
                          "'CHECK (' || consrc || ')' AS consrc, "
                          "true as convalidated "
                          "FROM pg_catalog.pg_constraint "
                          "WHERE contypid = '%u'::pg_catalog.oid "
                          "ORDER BY conname",
                          tyinfo->dobj.catId.oid);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_conname = PQfnumber(res, "conname");
    i_consrc = PQfnumber(res, "consrc");

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

    tyinfo->nDomChecks = ntups;
    tyinfo->domChecks = constrinfo;

    for (i = 0; i < ntups; i++)
    {
        bool        validated = PQgetvalue(res, i, 4)[0] == 't';

        constrinfo[i].dobj.objType = DO_CONSTRAINT;
        constrinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        constrinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&constrinfo[i].dobj);
        constrinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_conname));
        constrinfo[i].dobj.namespace = tyinfo->dobj.namespace;
        constrinfo[i].contable = NULL;
        constrinfo[i].condomain = tyinfo;
        constrinfo[i].contype = 'c';
        constrinfo[i].condef = pg_strdup(PQgetvalue(res, i, i_consrc));
        constrinfo[i].confrelid = InvalidOid;
        constrinfo[i].conindex = 0;
        constrinfo[i].condeferrable = false;
        constrinfo[i].condeferred = false;
        constrinfo[i].conislocal = true;

        constrinfo[i].separate = !validated;

        /*
         * Make the domain depend on the constraint, ensuring it won't be
         * output till any constraint dependencies are OK.  If the constraint
         * has not been validated, it's going to be dumped after the domain
         * anyway, so this doesn't matter.
         */
        if (validated)
            addObjectDependency(&tyinfo->dobj,
                                constrinfo[i].dobj.dumpId);
    }

    PQclear(res);

    destroyPQExpBuffer(query);
}

EventTriggerInfo* getEventTriggers ( Archive fout,
int *  numEventTriggers 
)

Definition at line 5747 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _evttriggerInfo::dobj, _evttriggerInfo::evtenabled, _evttriggerInfo::evtevent, _evttriggerInfo::evtfname, _evttriggerInfo::evtname, _evttriggerInfo::evtowner, _evttriggerInfo::evttags, ExecuteSqlQuery(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    EventTriggerInfo *evtinfo;
    int         i_tableoid,
                i_oid,
                i_evtname,
                i_evtevent,
                i_evtowner,
                i_evttags,
                i_evtfname,
                i_evtenabled;
    int         ntups;

    /* Before 9.3, there are no event triggers */
    if (fout->remoteVersion < 90300)
    {
        *numEventTriggers = 0;
        return NULL;
    }

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query,
                      "SELECT e.tableoid, e.oid, evtname, evtenabled, "
                      "evtevent, (%s evtowner) AS evtowner, "
                      "array_to_string(array("
                      "select quote_literal(x) "
                      " from unnest(evttags) as t(x)), ', ') as evttags, "
                      "e.evtfoid::regproc as evtfname "
                      "FROM pg_event_trigger e "
                      "ORDER BY e.oid",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numEventTriggers = ntups;

    evtinfo = (EventTriggerInfo *) pg_malloc(ntups * sizeof(EventTriggerInfo));

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_evtname = PQfnumber(res, "evtname");
    i_evtevent = PQfnumber(res, "evtevent");
    i_evtowner = PQfnumber(res, "evtowner");
    i_evttags = PQfnumber(res, "evttags");
    i_evtfname = PQfnumber(res, "evtfname");
    i_evtenabled = PQfnumber(res, "evtenabled");

    for (i = 0; i < ntups; i++)
    {
        evtinfo[i].dobj.objType = DO_EVENT_TRIGGER;
        evtinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        evtinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&evtinfo[i].dobj);
        evtinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_evtname));
        evtinfo[i].evtname = pg_strdup(PQgetvalue(res, i, i_evtname));
        evtinfo[i].evtevent = pg_strdup(PQgetvalue(res, i, i_evtevent));
        evtinfo[i].evtowner = pg_strdup(PQgetvalue(res, i, i_evtowner));
        evtinfo[i].evttags = pg_strdup(PQgetvalue(res, i, i_evttags));
        evtinfo[i].evtfname = pg_strdup(PQgetvalue(res, i, i_evtfname));
        evtinfo[i].evtenabled = *(PQgetvalue(res, i, i_evtenabled));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return evtinfo;
}

void getExtensionMembership ( Archive fout,
ExtensionInfo  extinfo[],
int  numExtensions 
)

Definition at line 14499 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), atooid, binary_upgrade, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _tableInfo::dataObj, destroyPQExpBuffer(), _tableInfo::dobj, _extensionInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, ExecuteSqlQuery(), _dumpableObject::ext_member, _extensionInfo::extcondition, _extensionInfo::extconfig, _tableDataInfo::filtercond, findObjectByCatalogId(), findTableByOid(), free, SimpleOidList::head, i, makeTableDataInfo(), NULL, CatalogId::oid, parsePGArray(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), selectSourceSchema(), simple_oid_list_member(), and CatalogId::tableoid.

Referenced by getSchemaData().

{
    PQExpBuffer query;
    PGresult   *res;
    int         ntups,
                i;
    int         i_classid,
                i_objid,
                i_refclassid,
                i_refobjid;
    DumpableObject *dobj,
               *refdobj;

    /* Nothing to do if no extensions */
    if (numExtensions == 0)
        return;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    query = createPQExpBuffer();

    /* refclassid constraint is redundant but may speed the search */
    appendPQExpBuffer(query, "SELECT "
                      "classid, objid, refclassid, refobjid "
                      "FROM pg_depend "
                      "WHERE refclassid = 'pg_extension'::regclass "
                      "AND deptype = 'e' "
                      "ORDER BY 3,4");

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    i_classid = PQfnumber(res, "classid");
    i_objid = PQfnumber(res, "objid");
    i_refclassid = PQfnumber(res, "refclassid");
    i_refobjid = PQfnumber(res, "refobjid");

    /*
     * Since we ordered the SELECT by referenced ID, we can expect that
     * multiple entries for the same extension will appear together; this
     * saves on searches.
     */
    refdobj = NULL;

    for (i = 0; i < ntups; i++)
    {
        CatalogId   objId;
        CatalogId   refobjId;

        objId.tableoid = atooid(PQgetvalue(res, i, i_classid));
        objId.oid = atooid(PQgetvalue(res, i, i_objid));
        refobjId.tableoid = atooid(PQgetvalue(res, i, i_refclassid));
        refobjId.oid = atooid(PQgetvalue(res, i, i_refobjid));

        if (refdobj == NULL ||
            refdobj->catId.tableoid != refobjId.tableoid ||
            refdobj->catId.oid != refobjId.oid)
            refdobj = findObjectByCatalogId(refobjId);

        /*
         * Failure to find objects mentioned in pg_depend is not unexpected,
         * since for example we don't collect info about TOAST tables.
         */
        if (refdobj == NULL)
        {
#ifdef NOT_USED
            fprintf(stderr, "no referenced object %u %u\n",
                    refobjId.tableoid, refobjId.oid);
#endif
            continue;
        }

        dobj = findObjectByCatalogId(objId);

        if (dobj == NULL)
        {
#ifdef NOT_USED
            fprintf(stderr, "no referencing object %u %u\n",
                    objId.tableoid, objId.oid);
#endif
            continue;
        }

        /* Record dependency so that getDependencies needn't repeat this */
        addObjectDependency(dobj, refdobj->dumpId);

        dobj->ext_member = true;

        /*
         * Normally, mark the member object as not to be dumped.  But in
         * binary upgrades, we still dump the members individually, since the
         * idea is to exactly reproduce the database contents rather than
         * replace the extension contents with something different.
         */
        if (!binary_upgrade)
            dobj->dump = false;
        else
            dobj->dump = refdobj->dump;
    }

    PQclear(res);

    /*
     * Now identify extension configuration tables and create TableDataInfo
     * objects for them, ensuring their data will be dumped even though the
     * tables themselves won't be.
     *
     * Note that we create TableDataInfo objects even in schemaOnly mode, ie,
     * user data in a configuration table is treated like schema data. This
     * seems appropriate since system data in a config table would get
     * reloaded by CREATE EXTENSION.
     */
    for (i = 0; i < numExtensions; i++)
    {
        ExtensionInfo *curext = &(extinfo[i]);
        char       *extconfig = curext->extconfig;
        char       *extcondition = curext->extcondition;
        char      **extconfigarray = NULL;
        char      **extconditionarray = NULL;
        int         nconfigitems;
        int         nconditionitems;

        if (parsePGArray(extconfig, &extconfigarray, &nconfigitems) &&
          parsePGArray(extcondition, &extconditionarray, &nconditionitems) &&
            nconfigitems == nconditionitems)
        {
            int         j;

            for (j = 0; j < nconfigitems; j++)
            {
                TableInfo  *configtbl;
                Oid         configtbloid = atooid(extconfigarray[j]);
                bool        dumpobj = curext->dobj.dump;

                configtbl = findTableByOid(configtbloid);
                if (configtbl == NULL)
                    continue;

                /*
                 * Tables of not-to-be-dumped extensions shouldn't be dumped
                 * unless the table or its schema is explicitly included
                 */
                if (!curext->dobj.dump)
                {
                    /* check table explicitly requested */
                    if (table_include_oids.head != NULL &&
                        simple_oid_list_member(&table_include_oids,
                                                configtbloid))
                        dumpobj = true;

                    /* check table's schema explicitly requested */
                    if (configtbl->dobj.namespace->dobj.dump)
                        dumpobj = true;
                }

                /* check table excluded by an exclusion switch */
                if (table_exclude_oids.head != NULL &&
                    simple_oid_list_member(&table_exclude_oids,
                                            configtbloid))
                    dumpobj = false;

                /* check schema excluded by an exclusion switch */
                if (simple_oid_list_member(&schema_exclude_oids,
                    configtbl->dobj.namespace->dobj.catId.oid))
                    dumpobj = false;

                if (dumpobj)
                {
                    /*
                     * Note: config tables are dumped without OIDs regardless of
                     * the --oids setting.  This is because row filtering
                     * conditions aren't compatible with dumping OIDs.
                     */
                    makeTableDataInfo(configtbl, false);
                    if (configtbl->dataObj != NULL)
                    {
                        if (strlen(extconditionarray[j]) > 0)
                            configtbl->dataObj->filtercond = pg_strdup(extconditionarray[j]);
                    }
                }
            }
        }
        if (extconfigarray)
            free(extconfigarray);
        if (extconditionarray)
            free(extconditionarray);
    }

    destroyPQExpBuffer(query);
}

ExtensionInfo* getExtensions ( Archive fout,
int *  numExtensions 
)

Definition at line 3023 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _extensionInfo::dobj, ExecuteSqlQuery(), _extensionInfo::extcondition, _extensionInfo::extconfig, _extensionInfo::extversion, i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _extensionInfo::relocatable, Archive::remoteVersion, selectDumpableExtension(), selectSourceSchema(), and CatalogId::tableoid.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    ExtensionInfo *extinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_extname;
    int         i_nspname;
    int         i_extrelocatable;
    int         i_extversion;
    int         i_extconfig;
    int         i_extcondition;

    /*
     * Before 9.1, there are no extensions.
     */
    if (fout->remoteVersion < 90100)
    {
        *numExtensions = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT x.tableoid, x.oid, "
                      "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
                      "FROM pg_extension x "
                      "JOIN pg_namespace n ON n.oid = x.extnamespace");

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_extname = PQfnumber(res, "extname");
    i_nspname = PQfnumber(res, "nspname");
    i_extrelocatable = PQfnumber(res, "extrelocatable");
    i_extversion = PQfnumber(res, "extversion");
    i_extconfig = PQfnumber(res, "extconfig");
    i_extcondition = PQfnumber(res, "extcondition");

    for (i = 0; i < ntups; i++)
    {
        extinfo[i].dobj.objType = DO_EXTENSION;
        extinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        extinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&extinfo[i].dobj);
        extinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_extname));
        extinfo[i].namespace = pg_strdup(PQgetvalue(res, i, i_nspname));
        extinfo[i].relocatable = *(PQgetvalue(res, i, i_extrelocatable)) == 't';
        extinfo[i].extversion = pg_strdup(PQgetvalue(res, i, i_extversion));
        extinfo[i].extconfig = pg_strdup(PQgetvalue(res, i, i_extconfig));
        extinfo[i].extcondition = pg_strdup(PQgetvalue(res, i, i_extcondition));

        /* Decide whether we want to dump it */
        selectDumpableExtension(&(extinfo[i]));
    }

    PQclear(res);
    destroyPQExpBuffer(query);

    *numExtensions = ntups;

    return extinfo;
}

FdwInfo* getForeignDataWrappers ( Archive fout,
int *  numForeignDataWrappers 
)

Definition at line 7028 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _fdwInfo::dobj, ExecuteSqlQuery(), _fdwInfo::fdwacl, _fdwInfo::fdwhandler, _fdwInfo::fdwoptions, _fdwInfo::fdwvalidator, i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _fdwInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    FdwInfo    *fdwinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_fdwname;
    int         i_rolname;
    int         i_fdwhandler;
    int         i_fdwvalidator;
    int         i_fdwacl;
    int         i_fdwoptions;

    /* Before 8.4, there are no foreign-data wrappers */
    if (fout->remoteVersion < 80400)
    {
        *numForeignDataWrappers = 0;
        return NULL;
    }

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 90100)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, fdwname, "
                          "(%s fdwowner) AS rolname, "
                          "fdwhandler::pg_catalog.regproc, "
                          "fdwvalidator::pg_catalog.regproc, fdwacl, "
                          "array_to_string(ARRAY("
                          "SELECT quote_ident(option_name) || ' ' || "
                          "quote_literal(option_value) "
                          "FROM pg_options_to_table(fdwoptions) "
                          "ORDER BY option_name"
                          "), E',\n    ') AS fdwoptions "
                          "FROM pg_foreign_data_wrapper",
                          username_subquery);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, fdwname, "
                          "(%s fdwowner) AS rolname, "
                          "'-' AS fdwhandler, "
                          "fdwvalidator::pg_catalog.regproc, fdwacl, "
                          "array_to_string(ARRAY("
                          "SELECT quote_ident(option_name) || ' ' || "
                          "quote_literal(option_value) "
                          "FROM pg_options_to_table(fdwoptions) "
                          "ORDER BY option_name"
                          "), E',\n    ') AS fdwoptions "
                          "FROM pg_foreign_data_wrapper",
                          username_subquery);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numForeignDataWrappers = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_fdwname = PQfnumber(res, "fdwname");
    i_rolname = PQfnumber(res, "rolname");
    i_fdwhandler = PQfnumber(res, "fdwhandler");
    i_fdwvalidator = PQfnumber(res, "fdwvalidator");
    i_fdwacl = PQfnumber(res, "fdwacl");
    i_fdwoptions = PQfnumber(res, "fdwoptions");

    for (i = 0; i < ntups; i++)
    {
        fdwinfo[i].dobj.objType = DO_FDW;
        fdwinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        fdwinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&fdwinfo[i].dobj);
        fdwinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_fdwname));
        fdwinfo[i].dobj.namespace = NULL;
        fdwinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        fdwinfo[i].fdwhandler = pg_strdup(PQgetvalue(res, i, i_fdwhandler));
        fdwinfo[i].fdwvalidator = pg_strdup(PQgetvalue(res, i, i_fdwvalidator));
        fdwinfo[i].fdwoptions = pg_strdup(PQgetvalue(res, i, i_fdwoptions));
        fdwinfo[i].fdwacl = pg_strdup(PQgetvalue(res, i, i_fdwacl));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(fdwinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return fdwinfo;
}

ForeignServerInfo* getForeignServers ( Archive fout,
int *  numForeignServers 
)

Definition at line 7134 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _foreignServerInfo::dobj, ExecuteSqlQuery(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _foreignServerInfo::rolname, selectDumpableObject(), selectSourceSchema(), _foreignServerInfo::srvacl, _foreignServerInfo::srvfdw, _foreignServerInfo::srvoptions, _foreignServerInfo::srvtype, _foreignServerInfo::srvversion, CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    ForeignServerInfo *srvinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_srvname;
    int         i_rolname;
    int         i_srvfdw;
    int         i_srvtype;
    int         i_srvversion;
    int         i_srvacl;
    int         i_srvoptions;

    /* Before 8.4, there are no foreign servers */
    if (fout->remoteVersion < 80400)
    {
        *numForeignServers = 0;
        return NULL;
    }

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, srvname, "
                      "(%s srvowner) AS rolname, "
                      "srvfdw, srvtype, srvversion, srvacl,"
                      "array_to_string(ARRAY("
                      "SELECT quote_ident(option_name) || ' ' || "
                      "quote_literal(option_value) "
                      "FROM pg_options_to_table(srvoptions) "
                      "ORDER BY option_name"
                      "), E',\n    ') AS srvoptions "
                      "FROM pg_foreign_server",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numForeignServers = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_srvname = PQfnumber(res, "srvname");
    i_rolname = PQfnumber(res, "rolname");
    i_srvfdw = PQfnumber(res, "srvfdw");
    i_srvtype = PQfnumber(res, "srvtype");
    i_srvversion = PQfnumber(res, "srvversion");
    i_srvacl = PQfnumber(res, "srvacl");
    i_srvoptions = PQfnumber(res, "srvoptions");

    for (i = 0; i < ntups; i++)
    {
        srvinfo[i].dobj.objType = DO_FOREIGN_SERVER;
        srvinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        srvinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&srvinfo[i].dobj);
        srvinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_srvname));
        srvinfo[i].dobj.namespace = NULL;
        srvinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        srvinfo[i].srvfdw = atooid(PQgetvalue(res, i, i_srvfdw));
        srvinfo[i].srvtype = pg_strdup(PQgetvalue(res, i, i_srvtype));
        srvinfo[i].srvversion = pg_strdup(PQgetvalue(res, i, i_srvversion));
        srvinfo[i].srvoptions = pg_strdup(PQgetvalue(res, i, i_srvoptions));
        srvinfo[i].srvacl = pg_strdup(PQgetvalue(res, i, i_srvacl));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(srvinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return srvinfo;
}

static char * getFormattedTypeName ( Archive fout,
Oid  oid,
OidOptions  opts 
) [static]

Definition at line 15086 of file pg_dump.c.

References appendPQExpBuffer(), createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQueryForSingleRow(), fmtId(), g_opaque_type, pg_strdup(), PQclear(), PQgetvalue(), Archive::remoteVersion, zeroAsAny, zeroAsNone, zeroAsOpaque, and zeroAsStar.

Referenced by dumpBaseType(), dumpCast(), dumpFunc(), format_aggregate_signature(), format_function_arguments_old(), and format_function_signature().

{
    char       *result;
    PQExpBuffer query;
    PGresult   *res;

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

    query = createPQExpBuffer();
    if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT pg_catalog.format_type('%u'::pg_catalog.oid, NULL)",
                          oid);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT format_type('%u'::oid, NULL)",
                          oid);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT typname "
                          "FROM pg_type "
                          "WHERE oid = '%u'::oid",
                          oid);
    }

    res = ExecuteSqlQueryForSingleRow(fout, query->data);

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

    PQclear(res);
    destroyPQExpBuffer(query);

    return result;
}

FuncInfo* getFuncs ( Archive fout,
int *  numFuncs 
)

Definition at line 4015 of file pg_dump.c.

References appendPQExpBuffer(), _funcInfo::argtypes, AssignDumpId(), atooid, binary_upgrade, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _funcInfo::dobj, ExecuteSqlQuery(), findNamespace(), g_last_builtin_oid, i, _funcInfo::lang, _dumpableObject::name, _funcInfo::nargs, NULL, _dumpableObject::objType, CatalogId::oid, parseOidArray(), pg_malloc(), pg_malloc0(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _funcInfo::proacl, _funcInfo::proiargs, _funcInfo::prorettype, Archive::remoteVersion, _funcInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    FuncInfo   *finfo;
    int         i_tableoid;
    int         i_oid;
    int         i_proname;
    int         i_pronamespace;
    int         i_rolname;
    int         i_prolang;
    int         i_pronargs;
    int         i_proargtypes;
    int         i_prorettype;
    int         i_proacl;
    int         i_proiargs;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /*
     * Find all user-defined functions.  Normally we can exclude functions in
     * pg_catalog, which is worth doing since there are several thousand of
     * 'em.  However, there are some extensions that create functions in
     * pg_catalog.  In normal dumps we can still ignore those --- but in
     * binary-upgrade mode, we must dump the member objects of the extension,
     * so be sure to fetch any such functions.
     *
     * Also, in 9.2 and up, exclude functions that are internally dependent on
     * something else, since presumably those will be created as a result of
     * creating the something else.  This currently only acts to suppress
     * constructor functions for range types.  Note that this is OK only
     * because the constructors don't have any dependencies the range type
     * doesn't have; otherwise we might not get creation ordering correct.
     */

    if (fout->remoteVersion >= 80400)
    {
        appendPQExpBuffer(query,
                          "SELECT tableoid, oid, proname, prolang, "
                          "pronargs, proargtypes, prorettype, proacl, "
                          "pronamespace, "
            "pg_catalog.pg_get_function_identity_arguments(oid) AS proiargs,"
                          "(%s proowner) AS rolname "
                          "FROM pg_proc p "
                          "WHERE NOT proisagg AND ("
                          "pronamespace != "
                          "(SELECT oid FROM pg_namespace "
                          "WHERE nspname = 'pg_catalog')",
                          username_subquery);
        if (fout->remoteVersion >= 90200)
            appendPQExpBuffer(query,
                              "\n  AND NOT EXISTS (SELECT 1 FROM pg_depend "
                              "WHERE classid = 'pg_proc'::regclass AND "
                              "objid = p.oid AND deptype = 'i')");
        if (binary_upgrade && fout->remoteVersion >= 90100)
            appendPQExpBuffer(query,
                              "\n  OR EXISTS(SELECT 1 FROM pg_depend WHERE "
                              "classid = 'pg_proc'::regclass AND "
                              "objid = p.oid AND "
                              "refclassid = 'pg_extension'::regclass AND "
                              "deptype = 'e')");
        appendPQExpBuffer(query, ")");
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query,
                          "SELECT tableoid, oid, proname, prolang, "
                          "pronargs, proargtypes, prorettype, proacl, "
                          "pronamespace, "
                          "NULL::text AS proiargs,"
                          "(%s proowner) AS rolname "
                          "FROM pg_proc p "
                          "WHERE NOT proisagg AND ("
                          "pronamespace != "
                          "(SELECT oid FROM pg_namespace "
                          "WHERE nspname = 'pg_catalog'))",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query,
                          "SELECT tableoid, oid, proname, prolang, "
                          "pronargs, proargtypes, prorettype, "
                          "'{=X}' AS proacl, "
                          "0::oid AS pronamespace, "
                          "NULL::text AS proiargs,"
                          "(%s proowner) AS rolname "
                          "FROM pg_proc "
                          "WHERE pg_proc.oid > '%u'::oid",
                          username_subquery,
                          g_last_builtin_oid);
    }
    else
    {
        appendPQExpBuffer(query,
                          "SELECT "
                          "(SELECT oid FROM pg_class "
                          " WHERE relname = 'pg_proc') AS tableoid, "
                          "oid, proname, prolang, "
                          "pronargs, proargtypes, prorettype, "
                          "'{=X}' AS proacl, "
                          "0::oid AS pronamespace, "
                          "NULL::text AS proiargs,"
                          "(%s proowner) AS rolname "
                          "FROM pg_proc "
                          "where pg_proc.oid > '%u'::oid",
                          username_subquery,
                          g_last_builtin_oid);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numFuncs = ntups;

    finfo = (FuncInfo *) pg_malloc0(ntups * sizeof(FuncInfo));

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_proname = PQfnumber(res, "proname");
    i_pronamespace = PQfnumber(res, "pronamespace");
    i_rolname = PQfnumber(res, "rolname");
    i_prolang = PQfnumber(res, "prolang");
    i_pronargs = PQfnumber(res, "pronargs");
    i_proargtypes = PQfnumber(res, "proargtypes");
    i_prorettype = PQfnumber(res, "prorettype");
    i_proacl = PQfnumber(res, "proacl");
    i_proiargs = PQfnumber(res, "proiargs");

    for (i = 0; i < ntups; i++)
    {
        finfo[i].dobj.objType = DO_FUNC;
        finfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        finfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&finfo[i].dobj);
        finfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_proname));
        finfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_pronamespace)),
                          finfo[i].dobj.catId.oid);
        finfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        finfo[i].lang = atooid(PQgetvalue(res, i, i_prolang));
        finfo[i].prorettype = atooid(PQgetvalue(res, i, i_prorettype));
        finfo[i].proiargs = pg_strdup(PQgetvalue(res, i, i_proiargs));
        finfo[i].proacl = pg_strdup(PQgetvalue(res, i, i_proacl));
        finfo[i].nargs = atoi(PQgetvalue(res, i, i_pronargs));
        if (finfo[i].nargs == 0)
            finfo[i].argtypes = NULL;
        else
        {
            finfo[i].argtypes = (Oid *) pg_malloc(finfo[i].nargs * sizeof(Oid));
            parseOidArray(PQgetvalue(res, i, i_proargtypes),
                          finfo[i].argtypes, finfo[i].nargs);
        }

        /* Decide whether we want to dump it */
        selectDumpableObject(&(finfo[i].dobj));

        if (strlen(finfo[i].rolname) == 0)
            write_msg(NULL,
                 "WARNING: owner of function \"%s\" appears to be invalid\n",
                      finfo[i].dobj.name);
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return finfo;
}

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

Definition at line 4843 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::confrelid, _constraintInfo::conindex, _constraintInfo::conislocal, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _indxInfo::dobj, _tableInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, ExecuteSqlQuery(), g_verbose, _tableInfo::hasindex, i, INDEX_MAX_KEYS, _indxInfo::indexconstraint, _indxInfo::indexdef, _indxInfo::indextable, _indxInfo::indisclustered, _indxInfo::indkeys, _indxInfo::indnkeys, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, _indxInfo::options, parseOidArray(), pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _tableInfo::relkind, RELKIND_MATVIEW, RELKIND_RELATION, _indxInfo::relpages, Archive::remoteVersion, resetPQExpBuffer(), selectSourceSchema(), _constraintInfo::separate, CatalogId::tableoid, _indxInfo::tablespace, and write_msg().

Referenced by getSchemaData().

{
    int         i,
                j;
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    IndxInfo   *indxinfo;
    ConstraintInfo *constrinfo;
    int         i_tableoid,
                i_oid,
                i_indexname,
                i_indexdef,
                i_indnkeys,
                i_indkey,
                i_indisclustered,
                i_contype,
                i_conname,
                i_condeferrable,
                i_condeferred,
                i_contableoid,
                i_conoid,
                i_condef,
                i_tablespace,
                i_options,
                i_relpages;
    int         ntups;

    for (i = 0; i < numTables; i++)
    {
        TableInfo  *tbinfo = &tblinfo[i];

        /* Only plain tables and materialized views have indexes. */
        if (tbinfo->relkind != RELKIND_RELATION &&
            tbinfo->relkind != RELKIND_MATVIEW)
            continue;
        if (!tbinfo->hasindex)
            continue;

        /* Ignore indexes of tables not to be dumped */
        if (!tbinfo->dobj.dump)
            continue;

        if (g_verbose)
            write_msg(NULL, "reading indexes for table \"%s\"\n",
                      tbinfo->dobj.name);

        /* Make sure we are in proper schema so indexdef is right */
        selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

        /*
         * The point of the messy-looking outer join is to find a constraint
         * that is related by an internal dependency link to the index. If we
         * find one, create a CONSTRAINT entry linked to the INDEX entry.  We
         * assume an index won't have more than one internal dependency.
         *
         * As of 9.0 we don't need to look at pg_depend but can check for a
         * match to pg_constraint.conindid.  The check on conrelid is
         * redundant but useful because that column is indexed while conindid
         * is not.
         */
        resetPQExpBuffer(query);
        if (fout->remoteVersion >= 90000)
        {
            /*
             * the test on indisready is necessary in 9.2, and harmless in
             * earlier/later versions
             */
            appendPQExpBuffer(query,
                              "SELECT t.tableoid, t.oid, "
                              "t.relname AS indexname, "
                     "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
                              "t.relnatts AS indnkeys, "
                              "i.indkey, i.indisclustered, "
                              "t.relpages, "
                              "c.contype, c.conname, "
                              "c.condeferrable, c.condeferred, "
                              "c.tableoid AS contableoid, "
                              "c.oid AS conoid, "
                  "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
                              "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
                            "array_to_string(t.reloptions, ', ') AS options "
                              "FROM pg_catalog.pg_index i "
                      "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
                              "LEFT JOIN pg_catalog.pg_constraint c "
                              "ON (i.indrelid = c.conrelid AND "
                              "i.indexrelid = c.conindid AND "
                              "c.contype IN ('p','u','x')) "
                              "WHERE i.indrelid = '%u'::pg_catalog.oid "
                              "AND i.indisvalid AND i.indisready "
                              "ORDER BY indexname",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 80200)
        {
            appendPQExpBuffer(query,
                              "SELECT t.tableoid, t.oid, "
                              "t.relname AS indexname, "
                     "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
                              "t.relnatts AS indnkeys, "
                              "i.indkey, i.indisclustered, "
                              "t.relpages, "
                              "c.contype, c.conname, "
                              "c.condeferrable, c.condeferred, "
                              "c.tableoid AS contableoid, "
                              "c.oid AS conoid, "
                              "null AS condef, "
                              "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
                            "array_to_string(t.reloptions, ', ') AS options "
                              "FROM pg_catalog.pg_index i "
                      "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
                              "LEFT JOIN pg_catalog.pg_depend d "
                              "ON (d.classid = t.tableoid "
                              "AND d.objid = t.oid "
                              "AND d.deptype = 'i') "
                              "LEFT JOIN pg_catalog.pg_constraint c "
                              "ON (d.refclassid = c.tableoid "
                              "AND d.refobjid = c.oid) "
                              "WHERE i.indrelid = '%u'::pg_catalog.oid "
                              "AND i.indisvalid "
                              "ORDER BY indexname",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 80000)
        {
            appendPQExpBuffer(query,
                              "SELECT t.tableoid, t.oid, "
                              "t.relname AS indexname, "
                     "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
                              "t.relnatts AS indnkeys, "
                              "i.indkey, i.indisclustered, "
                              "t.relpages, "
                              "c.contype, c.conname, "
                              "c.condeferrable, c.condeferred, "
                              "c.tableoid AS contableoid, "
                              "c.oid AS conoid, "
                              "null AS condef, "
                              "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
                              "null AS options "
                              "FROM pg_catalog.pg_index i "
                      "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
                              "LEFT JOIN pg_catalog.pg_depend d "
                              "ON (d.classid = t.tableoid "
                              "AND d.objid = t.oid "
                              "AND d.deptype = 'i') "
                              "LEFT JOIN pg_catalog.pg_constraint c "
                              "ON (d.refclassid = c.tableoid "
                              "AND d.refobjid = c.oid) "
                              "WHERE i.indrelid = '%u'::pg_catalog.oid "
                              "ORDER BY indexname",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 70300)
        {
            appendPQExpBuffer(query,
                              "SELECT t.tableoid, t.oid, "
                              "t.relname AS indexname, "
                     "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
                              "t.relnatts AS indnkeys, "
                              "i.indkey, i.indisclustered, "
                              "t.relpages, "
                              "c.contype, c.conname, "
                              "c.condeferrable, c.condeferred, "
                              "c.tableoid AS contableoid, "
                              "c.oid AS conoid, "
                              "null AS condef, "
                              "NULL AS tablespace, "
                              "null AS options "
                              "FROM pg_catalog.pg_index i "
                      "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
                              "LEFT JOIN pg_catalog.pg_depend d "
                              "ON (d.classid = t.tableoid "
                              "AND d.objid = t.oid "
                              "AND d.deptype = 'i') "
                              "LEFT JOIN pg_catalog.pg_constraint c "
                              "ON (d.refclassid = c.tableoid "
                              "AND d.refobjid = c.oid) "
                              "WHERE i.indrelid = '%u'::pg_catalog.oid "
                              "ORDER BY indexname",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 70100)
        {
            appendPQExpBuffer(query,
                              "SELECT t.tableoid, t.oid, "
                              "t.relname AS indexname, "
                              "pg_get_indexdef(i.indexrelid) AS indexdef, "
                              "t.relnatts AS indnkeys, "
                              "i.indkey, false AS indisclustered, "
                              "t.relpages, "
                              "CASE WHEN i.indisprimary THEN 'p'::char "
                              "ELSE '0'::char END AS contype, "
                              "t.relname AS conname, "
                              "false AS condeferrable, "
                              "false AS condeferred, "
                              "0::oid AS contableoid, "
                              "t.oid AS conoid, "
                              "null AS condef, "
                              "NULL AS tablespace, "
                              "null AS options "
                              "FROM pg_index i, pg_class t "
                              "WHERE t.oid = i.indexrelid "
                              "AND i.indrelid = '%u'::oid "
                              "ORDER BY indexname",
                              tbinfo->dobj.catId.oid);
        }
        else
        {
            appendPQExpBuffer(query,
                              "SELECT "
                              "(SELECT oid FROM pg_class WHERE relname = 'pg_class') AS tableoid, "
                              "t.oid, "
                              "t.relname AS indexname, "
                              "pg_get_indexdef(i.indexrelid) AS indexdef, "
                              "t.relnatts AS indnkeys, "
                              "i.indkey, false AS indisclustered, "
                              "t.relpages, "
                              "CASE WHEN i.indisprimary THEN 'p'::char "
                              "ELSE '0'::char END AS contype, "
                              "t.relname AS conname, "
                              "false AS condeferrable, "
                              "false AS condeferred, "
                              "0::oid AS contableoid, "
                              "t.oid AS conoid, "
                              "null AS condef, "
                              "NULL AS tablespace, "
                              "null AS options "
                              "FROM pg_index i, pg_class t "
                              "WHERE t.oid = i.indexrelid "
                              "AND i.indrelid = '%u'::oid "
                              "ORDER BY indexname",
                              tbinfo->dobj.catId.oid);
        }

        res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

        ntups = PQntuples(res);

        i_tableoid = PQfnumber(res, "tableoid");
        i_oid = PQfnumber(res, "oid");
        i_indexname = PQfnumber(res, "indexname");
        i_indexdef = PQfnumber(res, "indexdef");
        i_indnkeys = PQfnumber(res, "indnkeys");
        i_indkey = PQfnumber(res, "indkey");
        i_indisclustered = PQfnumber(res, "indisclustered");
        i_relpages = PQfnumber(res, "relpages");
        i_contype = PQfnumber(res, "contype");
        i_conname = PQfnumber(res, "conname");
        i_condeferrable = PQfnumber(res, "condeferrable");
        i_condeferred = PQfnumber(res, "condeferred");
        i_contableoid = PQfnumber(res, "contableoid");
        i_conoid = PQfnumber(res, "conoid");
        i_condef = PQfnumber(res, "condef");
        i_tablespace = PQfnumber(res, "tablespace");
        i_options = PQfnumber(res, "options");

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

        for (j = 0; j < ntups; j++)
        {
            char        contype;

            indxinfo[j].dobj.objType = DO_INDEX;
            indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
            indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
            AssignDumpId(&indxinfo[j].dobj);
            indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
            indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
            indxinfo[j].indextable = tbinfo;
            indxinfo[j].indexdef = pg_strdup(PQgetvalue(res, j, i_indexdef));
            indxinfo[j].indnkeys = atoi(PQgetvalue(res, j, i_indnkeys));
            indxinfo[j].tablespace = pg_strdup(PQgetvalue(res, j, i_tablespace));
            indxinfo[j].options = pg_strdup(PQgetvalue(res, j, i_options));

            /*
             * In pre-7.4 releases, indkeys may contain more entries than
             * indnkeys says (since indnkeys will be 1 for a functional
             * index).  We don't actually care about this case since we don't
             * examine indkeys except for indexes associated with PRIMARY and
             * UNIQUE constraints, which are never functional indexes. But we
             * have to allocate enough space to keep parseOidArray from
             * complaining.
             */
            indxinfo[j].indkeys = (Oid *) pg_malloc(INDEX_MAX_KEYS * sizeof(Oid));
            parseOidArray(PQgetvalue(res, j, i_indkey),
                          indxinfo[j].indkeys, INDEX_MAX_KEYS);
            indxinfo[j].indisclustered = (PQgetvalue(res, j, i_indisclustered)[0] == 't');
            indxinfo[j].relpages = atoi(PQgetvalue(res, j, i_relpages));
            contype = *(PQgetvalue(res, j, i_contype));

            if (contype == 'p' || contype == 'u' || contype == 'x')
            {
                /*
                 * If we found a constraint matching the index, create an
                 * entry for it.
                 *
                 * In a pre-7.3 database, we take this path iff the index was
                 * marked indisprimary.
                 */
                constrinfo[j].dobj.objType = DO_CONSTRAINT;
                constrinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid));
                constrinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid));
                AssignDumpId(&constrinfo[j].dobj);
                constrinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
                constrinfo[j].dobj.namespace = tbinfo->dobj.namespace;
                constrinfo[j].contable = tbinfo;
                constrinfo[j].condomain = NULL;
                constrinfo[j].contype = contype;
                if (contype == 'x')
                    constrinfo[j].condef = pg_strdup(PQgetvalue(res, j, i_condef));
                else
                    constrinfo[j].condef = NULL;
                constrinfo[j].confrelid = InvalidOid;
                constrinfo[j].conindex = indxinfo[j].dobj.dumpId;
                constrinfo[j].condeferrable = *(PQgetvalue(res, j, i_condeferrable)) == 't';
                constrinfo[j].condeferred = *(PQgetvalue(res, j, i_condeferred)) == 't';
                constrinfo[j].conislocal = true;
                constrinfo[j].separate = true;

                indxinfo[j].indexconstraint = constrinfo[j].dobj.dumpId;

                /* If pre-7.3 DB, better make sure table comes first */
                addObjectDependency(&constrinfo[j].dobj,
                                    tbinfo->dobj.dumpId);
            }
            else
            {
                /* Plain secondary index */
                indxinfo[j].indexconstraint = 0;
            }
        }

        PQclear(res);
    }

    destroyPQExpBuffer(query);
}

InhInfo* getInherits ( Archive fout,
int *  numInherits 
)

Definition at line 4793 of file pg_dump.c.

References appendPQExpBuffer(), atooid, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlQuery(), i, _inhInfo::inhparent, _inhInfo::inhrelid, pg_malloc(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), and selectSourceSchema().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    InhInfo    *inhinfo;

    int         i_inhrelid;
    int         i_inhparent;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /* find all the inheritance information */

    appendPQExpBuffer(query, "SELECT inhrelid, inhparent FROM pg_inherits");

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numInherits = ntups;

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

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

    for (i = 0; i < ntups; i++)
    {
        inhinfo[i].inhrelid = atooid(PQgetvalue(res, i, i_inhrelid));
        inhinfo[i].inhparent = atooid(PQgetvalue(res, i, i_inhparent));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return inhinfo;
}

NamespaceInfo* getNamespaces ( Archive fout,
int *  numNamespaces 
)

Definition at line 2881 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _namespaceInfo::dobj, ExecuteSqlQuery(), i, _dumpableObject::name, _namespaceInfo::nspacl, NULL, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _namespaceInfo::rolname, selectDumpableNamespace(), selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    NamespaceInfo *nsinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_nspname;
    int         i_rolname;
    int         i_nspacl;

    /*
     * Before 7.3, there are no real namespaces; create two dummy entries, one
     * for user stuff and one for system stuff.
     */
    if (fout->remoteVersion < 70300)
    {
        nsinfo = (NamespaceInfo *) pg_malloc(2 * sizeof(NamespaceInfo));

        nsinfo[0].dobj.objType = DO_NAMESPACE;
        nsinfo[0].dobj.catId.tableoid = 0;
        nsinfo[0].dobj.catId.oid = 0;
        AssignDumpId(&nsinfo[0].dobj);
        nsinfo[0].dobj.name = pg_strdup("public");
        nsinfo[0].rolname = pg_strdup("");
        nsinfo[0].nspacl = pg_strdup("");

        selectDumpableNamespace(&nsinfo[0]);

        nsinfo[1].dobj.objType = DO_NAMESPACE;
        nsinfo[1].dobj.catId.tableoid = 0;
        nsinfo[1].dobj.catId.oid = 1;
        AssignDumpId(&nsinfo[1].dobj);
        nsinfo[1].dobj.name = pg_strdup("pg_catalog");
        nsinfo[1].rolname = pg_strdup("");
        nsinfo[1].nspacl = pg_strdup("");

        selectDumpableNamespace(&nsinfo[1]);

        *numNamespaces = 2;

        return nsinfo;
    }

    query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /*
     * we fetch all namespaces including system ones, so that every object we
     * read in can be linked to a containing namespace.
     */
    appendPQExpBuffer(query, "SELECT tableoid, oid, nspname, "
                      "(%s nspowner) AS rolname, "
                      "nspacl FROM pg_namespace",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_nspname = PQfnumber(res, "nspname");
    i_rolname = PQfnumber(res, "rolname");
    i_nspacl = PQfnumber(res, "nspacl");

    for (i = 0; i < ntups; i++)
    {
        nsinfo[i].dobj.objType = DO_NAMESPACE;
        nsinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        nsinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&nsinfo[i].dobj);
        nsinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_nspname));
        nsinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        nsinfo[i].nspacl = pg_strdup(PQgetvalue(res, i, i_nspacl));

        /* Decide whether to dump this namespace */
        selectDumpableNamespace(&nsinfo[i]);

        if (strlen(nsinfo[i].rolname) == 0)
            write_msg(NULL, "WARNING: owner of schema \"%s\" appears to be invalid\n",
                      nsinfo[i].dobj.name);
    }

    PQclear(res);
    destroyPQExpBuffer(query);

    *numNamespaces = ntups;

    return nsinfo;
}

OpclassInfo* getOpclasses ( Archive fout,
int *  numOpclasses 
)

Definition at line 3650 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _opclassInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _opclassInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    OpclassInfo *opcinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_opcname;
    int         i_opcnamespace;
    int         i_rolname;

    /*
     * find all opclasses, including builtin opclasses; we filter out
     * system-defined opclasses at dump-out time.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, opcname, "
                          "opcnamespace, "
                          "(%s opcowner) AS rolname "
                          "FROM pg_opclass",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, opcname, "
                          "0::oid AS opcnamespace, "
                          "''::name AS rolname "
                          "FROM pg_opclass");
    }
    else
    {
        appendPQExpBuffer(query, "SELECT "
                          "(SELECT oid FROM pg_class WHERE relname = 'pg_opclass') AS tableoid, "
                          "oid, opcname, "
                          "0::oid AS opcnamespace, "
                          "''::name AS rolname "
                          "FROM pg_opclass");
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numOpclasses = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_opcname = PQfnumber(res, "opcname");
    i_opcnamespace = PQfnumber(res, "opcnamespace");
    i_rolname = PQfnumber(res, "rolname");

    for (i = 0; i < ntups; i++)
    {
        opcinfo[i].dobj.objType = DO_OPCLASS;
        opcinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        opcinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&opcinfo[i].dobj);
        opcinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_opcname));
        opcinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_opcnamespace)),
                          opcinfo[i].dobj.catId.oid);
        opcinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(opcinfo[i].dobj));

        if (fout->remoteVersion >= 70300)
        {
            if (strlen(opcinfo[i].rolname) == 0)
                write_msg(NULL, "WARNING: owner of operator class \"%s\" appears to be invalid\n",
                          opcinfo[i].dobj.name);
        }
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return opcinfo;
}

OprInfo* getOperators ( Archive fout,
int *  numOprs 
)

Definition at line 3381 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _oprInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, _oprInfo::oprcode, oprinfo, _oprInfo::oprkind, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _oprInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    OprInfo    *oprinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_oprname;
    int         i_oprnamespace;
    int         i_rolname;
    int         i_oprkind;
    int         i_oprcode;

    /*
     * find all operators, including builtin operators; we filter out
     * system-defined operators at dump-out time.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, oprname, "
                          "oprnamespace, "
                          "(%s oprowner) AS rolname, "
                          "oprkind, "
                          "oprcode::oid AS oprcode "
                          "FROM pg_operator",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, oprname, "
                          "0::oid AS oprnamespace, "
                          "(%s oprowner) AS rolname, "
                          "oprkind, "
                          "oprcode::oid AS oprcode "
                          "FROM pg_operator",
                          username_subquery);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT "
                          "(SELECT oid FROM pg_class WHERE relname = 'pg_operator') AS tableoid, "
                          "oid, oprname, "
                          "0::oid AS oprnamespace, "
                          "(%s oprowner) AS rolname, "
                          "oprkind, "
                          "oprcode::oid AS oprcode "
                          "FROM pg_operator",
                          username_subquery);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numOprs = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_oprname = PQfnumber(res, "oprname");
    i_oprnamespace = PQfnumber(res, "oprnamespace");
    i_rolname = PQfnumber(res, "rolname");
    i_oprkind = PQfnumber(res, "oprkind");
    i_oprcode = PQfnumber(res, "oprcode");

    for (i = 0; i < ntups; i++)
    {
        oprinfo[i].dobj.objType = DO_OPERATOR;
        oprinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        oprinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&oprinfo[i].dobj);
        oprinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_oprname));
        oprinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_oprnamespace)),
                          oprinfo[i].dobj.catId.oid);
        oprinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        oprinfo[i].oprkind = (PQgetvalue(res, i, i_oprkind))[0];
        oprinfo[i].oprcode = atooid(PQgetvalue(res, i, i_oprcode));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(oprinfo[i].dobj));

        if (strlen(oprinfo[i].rolname) == 0)
            write_msg(NULL, "WARNING: owner of operator \"%s\" appears to be invalid\n",
                      oprinfo[i].dobj.name);
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return oprinfo;
}

OpfamilyInfo* getOpfamilies ( Archive fout,
int *  numOpfamilies 
)

Definition at line 3748 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _opfamilyInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _opfamilyInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    OpfamilyInfo *opfinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_opfname;
    int         i_opfnamespace;
    int         i_rolname;

    /* Before 8.3, there is no separate concept of opfamilies */
    if (fout->remoteVersion < 80300)
    {
        *numOpfamilies = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /*
     * find all opfamilies, including builtin opfamilies; we filter out
     * system-defined opfamilies at dump-out time.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, opfname, "
                      "opfnamespace, "
                      "(%s opfowner) AS rolname "
                      "FROM pg_opfamily",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numOpfamilies = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_opfname = PQfnumber(res, "opfname");
    i_opfnamespace = PQfnumber(res, "opfnamespace");
    i_rolname = PQfnumber(res, "rolname");

    for (i = 0; i < ntups; i++)
    {
        opfinfo[i].dobj.objType = DO_OPFAMILY;
        opfinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        opfinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&opfinfo[i].dobj);
        opfinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_opfname));
        opfinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_opfnamespace)),
                          opfinfo[i].dobj.catId.oid);
        opfinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(opfinfo[i].dobj));

        if (fout->remoteVersion >= 70300)
        {
            if (strlen(opfinfo[i].rolname) == 0)
                write_msg(NULL, "WARNING: owner of operator family \"%s\" appears to be invalid\n",
                          opfinfo[i].dobj.name);
        }
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return opfinfo;
}

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

Definition at line 4759 of file pg_dump.c.

References _tableInfo::dobj, _dumpableObject::dump, findTableByOid(), i, _tableInfo::interesting, OidIsValid, and _tableInfo::owning_tab.

Referenced by getSchemaData().

{
    int         i;

    /*
     * Force sequences that are "owned" by table columns to be dumped whenever
     * their owning table is being dumped.
     */
    for (i = 0; i < numTables; i++)
    {
        TableInfo  *seqinfo = &tblinfo[i];
        TableInfo  *owning_tab;

        if (!OidIsValid(seqinfo->owning_tab))
            continue;           /* not an owned sequence */
        if (seqinfo->dobj.dump)
            continue;           /* no need to search */
        owning_tab = findTableByOid(seqinfo->owning_tab);
        if (owning_tab && owning_tab->dobj.dump)
        {
            seqinfo->interesting = true;
            seqinfo->dobj.dump = true;
        }
    }
}

ProcLangInfo* getProcLangs ( Archive fout,
int *  numProcLangs 
)

Definition at line 5833 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _funcInfo::dobj, _procLangInfo::dobj, _dumpableObject::dumpId, ExecuteSqlQuery(), findFuncByOid(), i, _procLangInfo::lanacl, _procLangInfo::laninline, _procLangInfo::lanowner, _procLangInfo::lanplcallfoid, _procLangInfo::lanpltrusted, _procLangInfo::lanvalidator, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    ProcLangInfo *planginfo;
    int         i_tableoid;
    int         i_oid;
    int         i_lanname;
    int         i_lanpltrusted;
    int         i_lanplcallfoid;
    int         i_laninline;
    int         i_lanvalidator;
    int         i_lanacl;
    int         i_lanowner;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 90000)
    {
        /* pg_language has a laninline column */
        appendPQExpBuffer(query, "SELECT tableoid, oid, "
                          "lanname, lanpltrusted, lanplcallfoid, "
                          "laninline, lanvalidator,  lanacl, "
                          "(%s lanowner) AS lanowner "
                          "FROM pg_language "
                          "WHERE lanispl "
                          "ORDER BY oid",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 80300)
    {
        /* pg_language has a lanowner column */
        appendPQExpBuffer(query, "SELECT tableoid, oid, "
                          "lanname, lanpltrusted, lanplcallfoid, "
                          "lanvalidator,  lanacl, "
                          "(%s lanowner) AS lanowner "
                          "FROM pg_language "
                          "WHERE lanispl "
                          "ORDER BY oid",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 80100)
    {
        /* Languages are owned by the bootstrap superuser, OID 10 */
        appendPQExpBuffer(query, "SELECT tableoid, oid, *, "
                          "(%s '10') AS lanowner "
                          "FROM pg_language "
                          "WHERE lanispl "
                          "ORDER BY oid",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70400)
    {
        /* Languages are owned by the bootstrap superuser, sysid 1 */
        appendPQExpBuffer(query, "SELECT tableoid, oid, *, "
                          "(%s '1') AS lanowner "
                          "FROM pg_language "
                          "WHERE lanispl "
                          "ORDER BY oid",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70100)
    {
        /* No clear notion of an owner at all before 7.4 ... */
        appendPQExpBuffer(query, "SELECT tableoid, oid, * FROM pg_language "
                          "WHERE lanispl "
                          "ORDER BY oid");
    }
    else
    {
        appendPQExpBuffer(query, "SELECT "
                          "(SELECT oid FROM pg_class WHERE relname = 'pg_language') AS tableoid, "
                          "oid, * FROM pg_language "
                          "WHERE lanispl "
                          "ORDER BY oid");
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numProcLangs = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_lanname = PQfnumber(res, "lanname");
    i_lanpltrusted = PQfnumber(res, "lanpltrusted");
    i_lanplcallfoid = PQfnumber(res, "lanplcallfoid");
    /* these may fail and return -1: */
    i_laninline = PQfnumber(res, "laninline");
    i_lanvalidator = PQfnumber(res, "lanvalidator");
    i_lanacl = PQfnumber(res, "lanacl");
    i_lanowner = PQfnumber(res, "lanowner");

    for (i = 0; i < ntups; i++)
    {
        planginfo[i].dobj.objType = DO_PROCLANG;
        planginfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        planginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&planginfo[i].dobj);

        planginfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_lanname));
        planginfo[i].lanpltrusted = *(PQgetvalue(res, i, i_lanpltrusted)) == 't';
        planginfo[i].lanplcallfoid = atooid(PQgetvalue(res, i, i_lanplcallfoid));
        if (i_laninline >= 0)
            planginfo[i].laninline = atooid(PQgetvalue(res, i, i_laninline));
        else
            planginfo[i].laninline = InvalidOid;
        if (i_lanvalidator >= 0)
            planginfo[i].lanvalidator = atooid(PQgetvalue(res, i, i_lanvalidator));
        else
            planginfo[i].lanvalidator = InvalidOid;
        if (i_lanacl >= 0)
            planginfo[i].lanacl = pg_strdup(PQgetvalue(res, i, i_lanacl));
        else
            planginfo[i].lanacl = pg_strdup("{=U}");
        if (i_lanowner >= 0)
            planginfo[i].lanowner = pg_strdup(PQgetvalue(res, i, i_lanowner));
        else
            planginfo[i].lanowner = pg_strdup("");

        if (fout->remoteVersion < 70300)
        {
            /*
             * We need to make a dependency to ensure the function will be
             * dumped first.  (In 7.3 and later the regular dependency
             * mechanism will handle this for us.)
             */
            FuncInfo   *funcInfo = findFuncByOid(planginfo[i].lanplcallfoid);

            if (funcInfo)
                addObjectDependency(&planginfo[i].dobj,
                                    funcInfo->dobj.dumpId);
        }
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return planginfo;
}

RuleInfo* getRules ( Archive fout,
int *  numRules 
)

Definition at line 5389 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, _ruleInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, _ruleInfo::ev_enabled, _ruleInfo::ev_type, ExecuteSqlQuery(), exit_horribly(), findTableByOid(), i, _ruleInfo::is_instead, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _tableInfo::relkind, RELKIND_MATVIEW, RELKIND_VIEW, _ruleInfo::reloptions, Archive::remoteVersion, _ruleInfo::ruletable, selectSourceSchema(), _ruleInfo::separate, and CatalogId::tableoid.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    RuleInfo   *ruleinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_rulename;
    int         i_ruletable;
    int         i_ev_type;
    int         i_is_instead;
    int         i_ev_enabled;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query, "SELECT "
                          "tableoid, oid, rulename, "
                          "ev_class AS ruletable, ev_type, is_instead, "
                          "ev_enabled "
                          "FROM pg_rewrite "
                          "ORDER BY oid");
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT "
                          "tableoid, oid, rulename, "
                          "ev_class AS ruletable, ev_type, is_instead, "
                          "'O'::char AS ev_enabled "
                          "FROM pg_rewrite "
                          "ORDER BY oid");
    }
    else
    {
        appendPQExpBuffer(query, "SELECT "
                          "(SELECT oid FROM pg_class WHERE relname = 'pg_rewrite') AS tableoid, "
                          "oid, rulename, "
                          "ev_class AS ruletable, ev_type, is_instead, "
                          "'O'::char AS ev_enabled "
                          "FROM pg_rewrite "
                          "ORDER BY oid");
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numRules = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_rulename = PQfnumber(res, "rulename");
    i_ruletable = PQfnumber(res, "ruletable");
    i_ev_type = PQfnumber(res, "ev_type");
    i_is_instead = PQfnumber(res, "is_instead");
    i_ev_enabled = PQfnumber(res, "ev_enabled");

    for (i = 0; i < ntups; i++)
    {
        Oid         ruletableoid;

        ruleinfo[i].dobj.objType = DO_RULE;
        ruleinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        ruleinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&ruleinfo[i].dobj);
        ruleinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_rulename));
        ruletableoid = atooid(PQgetvalue(res, i, i_ruletable));
        ruleinfo[i].ruletable = findTableByOid(ruletableoid);
        if (ruleinfo[i].ruletable == NULL)
            exit_horribly(NULL, "failed sanity check, parent table OID %u of pg_rewrite entry OID %u not found\n",
                          ruletableoid, ruleinfo[i].dobj.catId.oid);
        ruleinfo[i].dobj.namespace = ruleinfo[i].ruletable->dobj.namespace;
        ruleinfo[i].dobj.dump = ruleinfo[i].ruletable->dobj.dump;
        ruleinfo[i].ev_type = *(PQgetvalue(res, i, i_ev_type));
        ruleinfo[i].is_instead = *(PQgetvalue(res, i, i_is_instead)) == 't';
        ruleinfo[i].ev_enabled = *(PQgetvalue(res, i, i_ev_enabled));
        if (ruleinfo[i].ruletable)
        {
            /*
             * If the table is a view or materialized view, force its ON
             * SELECT rule to be sorted before the view itself --- this
             * ensures that any dependencies for the rule affect the table's
             * positioning. Other rules are forced to appear after their
             * table.
             */
            if ((ruleinfo[i].ruletable->relkind == RELKIND_VIEW ||
                 ruleinfo[i].ruletable->relkind == RELKIND_MATVIEW) &&
                ruleinfo[i].ev_type == '1' && ruleinfo[i].is_instead)
            {
                addObjectDependency(&ruleinfo[i].ruletable->dobj,
                                    ruleinfo[i].dobj.dumpId);
                /* We'll merge the rule into CREATE VIEW, if possible */
                ruleinfo[i].separate = false;
            }
            else
            {
                addObjectDependency(&ruleinfo[i].dobj,
                                    ruleinfo[i].ruletable->dobj.dumpId);
                ruleinfo[i].separate = true;
            }
        }
        else
            ruleinfo[i].separate = true;

        /*
         * If we're forced to break a dependency loop by dumping a view as a
         * table and separate _RETURN rule, we'll move the view's reloptions
         * to the rule.  (This is necessary because tables and views have
         * different valid reloptions, so we can't apply the options until the
         * backend knows it's a view.)  Otherwise the rule's reloptions stay
         * NULL.
         */
        ruleinfo[i].reloptions = NULL;
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return ruleinfo;
}

void getTableAttrs ( Archive fout,
TableInfo tblinfo,
int  numTables 
)

Definition at line 6115 of file pg_dump.c.

References addObjectDependency(), _attrDefInfo::adef_expr, _attrDefInfo::adnum, _attrDefInfo::adtable, appendPQExpBuffer(), AssignDumpId(), atooid, _tableInfo::attalign, _tableInfo::attcollation, _tableInfo::attfdwoptions, _tableInfo::attisdropped, _tableInfo::attislocal, _tableInfo::attlen, _tableInfo::attnames, _tableInfo::attoptions, _tableInfo::attrdefs, _tableInfo::attstattarget, _tableInfo::attstorage, _tableInfo::atttypmod, _tableInfo::atttypnames, _dumpableObject::catId, _tableInfo::checkexprs, _constraintInfo::condef, _constraintInfo::condeferrable, _constraintInfo::condeferred, _constraintInfo::condomain, _constraintInfo::confrelid, _constraintInfo::conindex, _constraintInfo::conislocal, _constraintInfo::contable, _constraintInfo::contype, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _constraintInfo::dobj, _attrDefInfo::dobj, _tableInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, ExecuteSqlQuery(), exit_horribly(), exit_nicely, g_verbose, i, _tableInfo::inhNotNull, _tableInfo::interesting, _dumpableObject::name, _tableInfo::ncheck, ngettext, _tableInfo::notnull, NULL, _tableInfo::numatts, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _tableInfo::relkind, RELKIND_SEQUENCE, RELKIND_VIEW, Archive::remoteVersion, resetPQExpBuffer(), selectSourceSchema(), _constraintInfo::separate, _attrDefInfo::separate, shouldPrintColumn(), CatalogId::tableoid, _tableInfo::typstorage, and write_msg().

Referenced by getSchemaData().

{
    int         i,
                j;
    PQExpBuffer q = createPQExpBuffer();
    int         i_attnum;
    int         i_attname;
    int         i_atttypname;
    int         i_atttypmod;
    int         i_attstattarget;
    int         i_attstorage;
    int         i_typstorage;
    int         i_attnotnull;
    int         i_atthasdef;
    int         i_attisdropped;
    int         i_attlen;
    int         i_attalign;
    int         i_attislocal;
    int         i_attoptions;
    int         i_attcollation;
    int         i_attfdwoptions;
    PGresult   *res;
    int         ntups;
    bool        hasdefaults;

    for (i = 0; i < numTables; i++)
    {
        TableInfo  *tbinfo = &tblinfo[i];

        /* Don't bother to collect info for sequences */
        if (tbinfo->relkind == RELKIND_SEQUENCE)
            continue;

        /* Don't bother with uninteresting tables, either */
        if (!tbinfo->interesting)
            continue;

        /*
         * Make sure we are in proper schema for this table; this allows
         * correct retrieval of formatted type names and default exprs
         */
        selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

        /* find all the user attributes and their types */

        /*
         * we must read the attribute names in attribute number order! because
         * we will use the attnum to index into the attnames array later.  We
         * actually ask to order by "attrelid, attnum" because (at least up to
         * 7.3) the planner is not smart enough to realize it needn't re-sort
         * the output of an indexscan on pg_attribute_relid_attnum_index.
         */
        if (g_verbose)
            write_msg(NULL, "finding the columns and types of table \"%s\"\n",
                      tbinfo->dobj.name);

        resetPQExpBuffer(q);

        if (fout->remoteVersion >= 90200)
        {
            /*
             * attfdwoptions is new in 9.2.
             */
            appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, "
                              "a.attstattarget, a.attstorage, t.typstorage, "
                              "a.attnotnull, a.atthasdef, a.attisdropped, "
                              "a.attlen, a.attalign, a.attislocal, "
                  "pg_catalog.format_type(t.oid,a.atttypmod) AS atttypname, "
                        "array_to_string(a.attoptions, ', ') AS attoptions, "
                              "CASE WHEN a.attcollation <> t.typcollation "
                           "THEN a.attcollation ELSE 0 END AS attcollation, "
                              "pg_catalog.array_to_string(ARRAY("
                              "SELECT pg_catalog.quote_ident(option_name) || "
                              "' ' || pg_catalog.quote_literal(option_value) "
                        "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
                              "ORDER BY option_name"
                              "), E',\n    ') AS attfdwoptions "
             "FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_type t "
                              "ON a.atttypid = t.oid "
                              "WHERE a.attrelid = '%u'::pg_catalog.oid "
                              "AND a.attnum > 0::pg_catalog.int2 "
                              "ORDER BY a.attrelid, a.attnum",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 90100)
        {
            /*
             * attcollation is new in 9.1.  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.
             */
            appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, "
                              "a.attstattarget, a.attstorage, t.typstorage, "
                              "a.attnotnull, a.atthasdef, a.attisdropped, "
                              "a.attlen, a.attalign, a.attislocal, "
                  "pg_catalog.format_type(t.oid,a.atttypmod) AS atttypname, "
                        "array_to_string(a.attoptions, ', ') AS attoptions, "
                              "CASE WHEN a.attcollation <> t.typcollation "
                           "THEN a.attcollation ELSE 0 END AS attcollation, "
                              "NULL AS attfdwoptions "
             "FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_type t "
                              "ON a.atttypid = t.oid "
                              "WHERE a.attrelid = '%u'::pg_catalog.oid "
                              "AND a.attnum > 0::pg_catalog.int2 "
                              "ORDER BY a.attrelid, a.attnum",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 90000)
        {
            /* attoptions is new in 9.0 */
            appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, "
                              "a.attstattarget, a.attstorage, t.typstorage, "
                              "a.attnotnull, a.atthasdef, a.attisdropped, "
                              "a.attlen, a.attalign, a.attislocal, "
                  "pg_catalog.format_type(t.oid,a.atttypmod) AS atttypname, "
                        "array_to_string(a.attoptions, ', ') AS attoptions, "
                              "0 AS attcollation, "
                              "NULL AS attfdwoptions "
             "FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_type t "
                              "ON a.atttypid = t.oid "
                              "WHERE a.attrelid = '%u'::pg_catalog.oid "
                              "AND a.attnum > 0::pg_catalog.int2 "
                              "ORDER BY a.attrelid, a.attnum",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 70300)
        {
            /* need left join here to not fail on dropped columns ... */
            appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, "
                              "a.attstattarget, a.attstorage, t.typstorage, "
                              "a.attnotnull, a.atthasdef, a.attisdropped, "
                              "a.attlen, a.attalign, a.attislocal, "
                  "pg_catalog.format_type(t.oid,a.atttypmod) AS atttypname, "
                              "'' AS attoptions, 0 AS attcollation, "
                              "NULL AS attfdwoptions "
             "FROM pg_catalog.pg_attribute a LEFT JOIN pg_catalog.pg_type t "
                              "ON a.atttypid = t.oid "
                              "WHERE a.attrelid = '%u'::pg_catalog.oid "
                              "AND a.attnum > 0::pg_catalog.int2 "
                              "ORDER BY a.attrelid, a.attnum",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 70100)
        {
            /*
             * attstattarget doesn't exist in 7.1.  It does exist in 7.2, but
             * we don't dump it because we can't tell whether it's been
             * explicitly set or was just a default.
             *
             * attislocal doesn't exist before 7.3, either; in older databases
             * we assume it's TRUE, else we'd fail to dump non-inherited atts.
             */
            appendPQExpBuffer(q, "SELECT a.attnum, a.attname, a.atttypmod, "
                              "-1 AS attstattarget, a.attstorage, "
                              "t.typstorage, a.attnotnull, a.atthasdef, "
                              "false AS attisdropped, a.attlen, "
                              "a.attalign, true AS attislocal, "
                              "format_type(t.oid,a.atttypmod) AS atttypname, "
                              "'' AS attoptions, 0 AS attcollation, "
                              "NULL AS attfdwoptions "
                              "FROM pg_attribute a LEFT JOIN pg_type t "
                              "ON a.atttypid = t.oid "
                              "WHERE a.attrelid = '%u'::oid "
                              "AND a.attnum > 0::int2 "
                              "ORDER BY a.attrelid, a.attnum",
                              tbinfo->dobj.catId.oid);
        }
        else
        {
            /* format_type not available before 7.1 */
            appendPQExpBuffer(q, "SELECT attnum, attname, atttypmod, "
                              "-1 AS attstattarget, "
                              "attstorage, attstorage AS typstorage, "
                              "attnotnull, atthasdef, false AS attisdropped, "
                              "attlen, attalign, "
                              "true AS attislocal, "
                              "(SELECT typname FROM pg_type WHERE oid = atttypid) AS atttypname, "
                              "'' AS attoptions, 0 AS attcollation, "
                              "NULL AS attfdwoptions "
                              "FROM pg_attribute a "
                              "WHERE attrelid = '%u'::oid "
                              "AND attnum > 0::int2 "
                              "ORDER BY attrelid, attnum",
                              tbinfo->dobj.catId.oid);
        }

        res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);

        ntups = PQntuples(res);

        i_attnum = PQfnumber(res, "attnum");
        i_attname = PQfnumber(res, "attname");
        i_atttypname = PQfnumber(res, "atttypname");
        i_atttypmod = PQfnumber(res, "atttypmod");
        i_attstattarget = PQfnumber(res, "attstattarget");
        i_attstorage = PQfnumber(res, "attstorage");
        i_typstorage = PQfnumber(res, "typstorage");
        i_attnotnull = PQfnumber(res, "attnotnull");
        i_atthasdef = PQfnumber(res, "atthasdef");
        i_attisdropped = PQfnumber(res, "attisdropped");
        i_attlen = PQfnumber(res, "attlen");
        i_attalign = PQfnumber(res, "attalign");
        i_attislocal = PQfnumber(res, "attislocal");
        i_attoptions = PQfnumber(res, "attoptions");
        i_attcollation = PQfnumber(res, "attcollation");
        i_attfdwoptions = PQfnumber(res, "attfdwoptions");

        tbinfo->numatts = ntups;
        tbinfo->attnames = (char **) pg_malloc(ntups * sizeof(char *));
        tbinfo->atttypnames = (char **) pg_malloc(ntups * sizeof(char *));
        tbinfo->atttypmod = (int *) pg_malloc(ntups * sizeof(int));
        tbinfo->attstattarget = (int *) pg_malloc(ntups * sizeof(int));
        tbinfo->attstorage = (char *) pg_malloc(ntups * sizeof(char));
        tbinfo->typstorage = (char *) pg_malloc(ntups * sizeof(char));
        tbinfo->attisdropped = (bool *) pg_malloc(ntups * sizeof(bool));
        tbinfo->attlen = (int *) pg_malloc(ntups * sizeof(int));
        tbinfo->attalign = (char *) pg_malloc(ntups * sizeof(char));
        tbinfo->attislocal = (bool *) pg_malloc(ntups * sizeof(bool));
        tbinfo->attoptions = (char **) pg_malloc(ntups * sizeof(char *));
        tbinfo->attcollation = (Oid *) pg_malloc(ntups * sizeof(Oid));
        tbinfo->attfdwoptions = (char **) pg_malloc(ntups * sizeof(char *));
        tbinfo->notnull = (bool *) pg_malloc(ntups * sizeof(bool));
        tbinfo->inhNotNull = (bool *) pg_malloc(ntups * sizeof(bool));
        tbinfo->attrdefs = (AttrDefInfo **) pg_malloc(ntups * sizeof(AttrDefInfo *));
        hasdefaults = false;

        for (j = 0; j < ntups; j++)
        {
            if (j + 1 != atoi(PQgetvalue(res, j, i_attnum)))
                exit_horribly(NULL,
                              "invalid column numbering in table \"%s\"\n",
                              tbinfo->dobj.name);
            tbinfo->attnames[j] = pg_strdup(PQgetvalue(res, j, i_attname));
            tbinfo->atttypnames[j] = pg_strdup(PQgetvalue(res, j, i_atttypname));
            tbinfo->atttypmod[j] = atoi(PQgetvalue(res, j, i_atttypmod));
            tbinfo->attstattarget[j] = atoi(PQgetvalue(res, j, i_attstattarget));
            tbinfo->attstorage[j] = *(PQgetvalue(res, j, i_attstorage));
            tbinfo->typstorage[j] = *(PQgetvalue(res, j, i_typstorage));
            tbinfo->attisdropped[j] = (PQgetvalue(res, j, i_attisdropped)[0] == 't');
            tbinfo->attlen[j] = atoi(PQgetvalue(res, j, i_attlen));
            tbinfo->attalign[j] = *(PQgetvalue(res, j, i_attalign));
            tbinfo->attislocal[j] = (PQgetvalue(res, j, i_attislocal)[0] == 't');
            tbinfo->notnull[j] = (PQgetvalue(res, j, i_attnotnull)[0] == 't');
            tbinfo->attoptions[j] = pg_strdup(PQgetvalue(res, j, i_attoptions));
            tbinfo->attcollation[j] = atooid(PQgetvalue(res, j, i_attcollation));
            tbinfo->attfdwoptions[j] = pg_strdup(PQgetvalue(res, j, i_attfdwoptions));
            tbinfo->attrdefs[j] = NULL; /* fix below */
            if (PQgetvalue(res, j, i_atthasdef)[0] == 't')
                hasdefaults = true;
            /* these flags will be set in flagInhAttrs() */
            tbinfo->inhNotNull[j] = false;
        }

        PQclear(res);

        /*
         * Get info about column defaults
         */
        if (hasdefaults)
        {
            AttrDefInfo *attrdefs;
            int         numDefaults;

            if (g_verbose)
                write_msg(NULL, "finding default expressions of table \"%s\"\n",
                          tbinfo->dobj.name);

            resetPQExpBuffer(q);
            if (fout->remoteVersion >= 70300)
            {
                appendPQExpBuffer(q, "SELECT tableoid, oid, adnum, "
                           "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc "
                                  "FROM pg_catalog.pg_attrdef "
                                  "WHERE adrelid = '%u'::pg_catalog.oid",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 70200)
            {
                /* 7.2 did not have OIDs in pg_attrdef */
                appendPQExpBuffer(q, "SELECT tableoid, 0 AS oid, adnum, "
                                  "pg_get_expr(adbin, adrelid) AS adsrc "
                                  "FROM pg_attrdef "
                                  "WHERE adrelid = '%u'::oid",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 70100)
            {
                /* no pg_get_expr, so must rely on adsrc */
                appendPQExpBuffer(q, "SELECT tableoid, oid, adnum, adsrc "
                                  "FROM pg_attrdef "
                                  "WHERE adrelid = '%u'::oid",
                                  tbinfo->dobj.catId.oid);
            }
            else
            {
                /* no pg_get_expr, no tableoid either */
                appendPQExpBuffer(q, "SELECT "
                                  "(SELECT oid FROM pg_class WHERE relname = 'pg_attrdef') AS tableoid, "
                                  "oid, adnum, adsrc "
                                  "FROM pg_attrdef "
                                  "WHERE adrelid = '%u'::oid",
                                  tbinfo->dobj.catId.oid);
            }
            res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);

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

            for (j = 0; j < numDefaults; j++)
            {
                int         adnum;

                adnum = atoi(PQgetvalue(res, j, 2));

                if (adnum <= 0 || adnum > ntups)
                    exit_horribly(NULL,
                                  "invalid adnum value %d for table \"%s\"\n",
                                  adnum, tbinfo->dobj.name);

                /*
                 * dropped columns shouldn't have defaults, but just in case,
                 * ignore 'em
                 */
                if (tbinfo->attisdropped[adnum - 1])
                    continue;

                attrdefs[j].dobj.objType = DO_ATTRDEF;
                attrdefs[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, 0));
                attrdefs[j].dobj.catId.oid = atooid(PQgetvalue(res, j, 1));
                AssignDumpId(&attrdefs[j].dobj);
                attrdefs[j].adtable = tbinfo;
                attrdefs[j].adnum = adnum;
                attrdefs[j].adef_expr = pg_strdup(PQgetvalue(res, j, 3));

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

                attrdefs[j].dobj.dump = tbinfo->dobj.dump;

                /*
                 * Defaults on a VIEW must always be dumped as separate ALTER
                 * TABLE commands.  Defaults on regular tables are dumped as
                 * part of the CREATE TABLE if possible, which it won't be if
                 * the column is not going to be emitted explicitly.
                 */
                if (tbinfo->relkind == RELKIND_VIEW)
                {
                    attrdefs[j].separate = true;
                    /* needed in case pre-7.3 DB: */
                    addObjectDependency(&attrdefs[j].dobj,
                                        tbinfo->dobj.dumpId);
                }
                else if (!shouldPrintColumn(tbinfo, adnum - 1))
                {
                    /* column will be suppressed, print default separately */
                    attrdefs[j].separate = true;
                    /* needed in case pre-7.3 DB: */
                    addObjectDependency(&attrdefs[j].dobj,
                                        tbinfo->dobj.dumpId);
                }
                else
                {
                    attrdefs[j].separate = false;

                    /*
                     * Mark the default as needing to appear before the table,
                     * so that any dependencies it has must be emitted before
                     * the CREATE TABLE.  If this is not possible, we'll
                     * change to "separate" mode while sorting dependencies.
                     */
                    addObjectDependency(&tbinfo->dobj,
                                        attrdefs[j].dobj.dumpId);
                }

                tbinfo->attrdefs[adnum - 1] = &attrdefs[j];
            }
            PQclear(res);
        }

        /*
         * Get info about table CHECK constraints
         */
        if (tbinfo->ncheck > 0)
        {
            ConstraintInfo *constrs;
            int         numConstrs;

            if (g_verbose)
                write_msg(NULL, "finding check constraints for table \"%s\"\n",
                          tbinfo->dobj.name);

            resetPQExpBuffer(q);
            if (fout->remoteVersion >= 90200)
            {
                /*
                 * convalidated is new in 9.2 (actually, it is there in 9.1,
                 * but it wasn't ever false for check constraints until 9.2).
                 */
                appendPQExpBuffer(q, "SELECT tableoid, oid, conname, "
                           "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
                                  "conislocal, convalidated "
                                  "FROM pg_catalog.pg_constraint "
                                  "WHERE conrelid = '%u'::pg_catalog.oid "
                                  "   AND contype = 'c' "
                                  "ORDER BY conname",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 80400)
            {
                /* conislocal is new in 8.4 */
                appendPQExpBuffer(q, "SELECT tableoid, oid, conname, "
                           "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
                                  "conislocal, true AS convalidated "
                                  "FROM pg_catalog.pg_constraint "
                                  "WHERE conrelid = '%u'::pg_catalog.oid "
                                  "   AND contype = 'c' "
                                  "ORDER BY conname",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 70400)
            {
                appendPQExpBuffer(q, "SELECT tableoid, oid, conname, "
                           "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
                                  "true AS conislocal, true AS convalidated "
                                  "FROM pg_catalog.pg_constraint "
                                  "WHERE conrelid = '%u'::pg_catalog.oid "
                                  "   AND contype = 'c' "
                                  "ORDER BY conname",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 70300)
            {
                /* no pg_get_constraintdef, must use consrc */
                appendPQExpBuffer(q, "SELECT tableoid, oid, conname, "
                                  "'CHECK (' || consrc || ')' AS consrc, "
                                  "true AS conislocal, true AS convalidated "
                                  "FROM pg_catalog.pg_constraint "
                                  "WHERE conrelid = '%u'::pg_catalog.oid "
                                  "   AND contype = 'c' "
                                  "ORDER BY conname",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 70200)
            {
                /* 7.2 did not have OIDs in pg_relcheck */
                appendPQExpBuffer(q, "SELECT tableoid, 0 AS oid, "
                                  "rcname AS conname, "
                                  "'CHECK (' || rcsrc || ')' AS consrc, "
                                  "true AS conislocal, true AS convalidated "
                                  "FROM pg_relcheck "
                                  "WHERE rcrelid = '%u'::oid "
                                  "ORDER BY rcname",
                                  tbinfo->dobj.catId.oid);
            }
            else if (fout->remoteVersion >= 70100)
            {
                appendPQExpBuffer(q, "SELECT tableoid, oid, "
                                  "rcname AS conname, "
                                  "'CHECK (' || rcsrc || ')' AS consrc, "
                                  "true AS conislocal, true AS convalidated "
                                  "FROM pg_relcheck "
                                  "WHERE rcrelid = '%u'::oid "
                                  "ORDER BY rcname",
                                  tbinfo->dobj.catId.oid);
            }
            else
            {
                /* no tableoid in 7.0 */
                appendPQExpBuffer(q, "SELECT "
                                  "(SELECT oid FROM pg_class WHERE relname = 'pg_relcheck') AS tableoid, "
                                  "oid, rcname AS conname, "
                                  "'CHECK (' || rcsrc || ')' AS consrc, "
                                  "true AS conislocal, true AS convalidated "
                                  "FROM pg_relcheck "
                                  "WHERE rcrelid = '%u'::oid "
                                  "ORDER BY rcname",
                                  tbinfo->dobj.catId.oid);
            }
            res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);

            numConstrs = PQntuples(res);
            if (numConstrs != tbinfo->ncheck)
            {
                write_msg(NULL, ngettext("expected %d check constraint on table \"%s\" but found %d\n",
                                         "expected %d check constraints on table \"%s\" but found %d\n",
                                         tbinfo->ncheck),
                          tbinfo->ncheck, tbinfo->dobj.name, numConstrs);
                write_msg(NULL, "(The system catalogs might be corrupted.)\n");
                exit_nicely(1);
            }

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

            for (j = 0; j < numConstrs; j++)
            {
                bool        validated = PQgetvalue(res, j, 5)[0] == 't';

                constrs[j].dobj.objType = DO_CONSTRAINT;
                constrs[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, 0));
                constrs[j].dobj.catId.oid = atooid(PQgetvalue(res, j, 1));
                AssignDumpId(&constrs[j].dobj);
                constrs[j].dobj.name = pg_strdup(PQgetvalue(res, j, 2));
                constrs[j].dobj.namespace = tbinfo->dobj.namespace;
                constrs[j].contable = tbinfo;
                constrs[j].condomain = NULL;
                constrs[j].contype = 'c';
                constrs[j].condef = pg_strdup(PQgetvalue(res, j, 3));
                constrs[j].confrelid = InvalidOid;
                constrs[j].conindex = 0;
                constrs[j].condeferrable = false;
                constrs[j].condeferred = false;
                constrs[j].conislocal = (PQgetvalue(res, j, 4)[0] == 't');

                /*
                 * An unvalidated constraint needs to be dumped separately, so
                 * that potentially-violating existing data is loaded before
                 * the constraint.
                 */
                constrs[j].separate = !validated;

                constrs[j].dobj.dump = tbinfo->dobj.dump;

                /*
                 * Mark the constraint as needing to appear before the table
                 * --- this is so that any other dependencies of the
                 * constraint will be emitted before we try to create the
                 * table.  If the constraint is to be dumped separately, it
                 * will be dumped after data is loaded anyway, so don't do it.
                 * (There's an automatic dependency in the opposite direction
                 * anyway, so don't need to add one manually here.)
                 */
                if (!constrs[j].separate)
                    addObjectDependency(&tbinfo->dobj,
                                        constrs[j].dobj.dumpId);

                /*
                 * If the constraint is inherited, this will be detected later
                 * (in pre-8.4 databases).  We also detect later if the
                 * constraint must be split out from the table definition.
                 */
            }
            PQclear(res);
        }
    }

    destroyPQExpBuffer(q);
}

static void getTableData ( TableInfo tblinfo,
int  numTables,
bool  oids 
) [static]

Definition at line 1796 of file pg_dump.c.

References i, and makeTableDataInfo().

Referenced by main().

{
    int         i;

    for (i = 0; i < numTables; i++)
    {
        if (tblinfo[i].dobj.dump)
            makeTableDataInfo(&(tblinfo[i]), oids);
    }
}

static void getTableDataFKConstraints ( void   )  [static]

Definition at line 1991 of file pg_dump.c.

References addObjectDependency(), _constraintInfo::confrelid, _constraintInfo::contable, _tableInfo::dataObj, DO_FK_CONSTRAINT, _tableDataInfo::dobj, _dumpableObject::dumpId, findTableByOid(), free, getDumpableObjects(), i, and NULL.

Referenced by main().

{
    DumpableObject **dobjs;
    int         numObjs;
    int         i;

    /* Search through all the dumpable objects for FK constraints */
    getDumpableObjects(&dobjs, &numObjs);
    for (i = 0; i < numObjs; i++)
    {
        if (dobjs[i]->objType == DO_FK_CONSTRAINT)
        {
            ConstraintInfo *cinfo = (ConstraintInfo *) dobjs[i];
            TableInfo  *ftable;

            /* Not interesting unless both tables are to be dumped */
            if (cinfo->contable == NULL ||
                cinfo->contable->dataObj == NULL)
                continue;
            ftable = findTableByOid(cinfo->confrelid);
            if (ftable == NULL ||
                ftable->dataObj == NULL)
                continue;

            /*
             * Okay, make referencing table's TABLE_DATA object depend on the
             * referenced table's TABLE_DATA object.
             */
            addObjectDependency(&cinfo->contable->dataObj->dobj,
                                ftable->dataObj->dobj.dumpId);
        }
    }
    free(dobjs);
}

TableInfo* getTables ( Archive fout,
int *  numTables 
)

Definition at line 4198 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralConn(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tableInfo::dobj, _dumpableObject::dump, ExecuteSqlQuery(), ExecuteSqlStatement(), findNamespace(), fmtQualifiedId(), _tableInfo::frozenxid, GetConnection(), _tableInfo::hasindex, _tableInfo::hasoids, _tableInfo::hasrules, _tableInfo::hastriggers, i, _tableInfo::interesting, _tableInfo::isscannable, lockWaitTimeout, _dumpableObject::name, _tableInfo::ncheck, NULL, _dumpableObject::objType, CatalogId::oid, _tableInfo::owning_col, _tableInfo::owning_tab, pg_malloc0(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), PQntuples(), _tableInfo::relacl, _tableInfo::relkind, RELKIND_COMPOSITE_TYPE, RELKIND_FOREIGN_TABLE, RELKIND_MATVIEW, RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW, _tableInfo::reloftype, _tableInfo::reloptions, _tableInfo::relpages, _tableInfo::relpersistence, _tableInfo::reltablespace, Archive::remoteVersion, resetPQExpBuffer(), _tableInfo::rolname, selectDumpableTable(), selectSourceSchema(), CatalogId::tableoid, tblinfo, _tableInfo::toast_frozenxid, _tableInfo::toast_oid, _tableInfo::toast_reloptions, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    TableInfo  *tblinfo;
    int         i_reltableoid;
    int         i_reloid;
    int         i_relname;
    int         i_relnamespace;
    int         i_relkind;
    int         i_relacl;
    int         i_rolname;
    int         i_relchecks;
    int         i_relhastriggers;
    int         i_relhasindex;
    int         i_relhasrules;
    int         i_relhasoids;
    int         i_relfrozenxid;
    int         i_toastoid;
    int         i_toastfrozenxid;
    int         i_relpersistence;
    int         i_isscannable;
    int         i_owning_tab;
    int         i_owning_col;
    int         i_reltablespace;
    int         i_reloptions;
    int         i_toastreloptions;
    int         i_reloftype;
    int         i_relpages;

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    /*
     * Find all the tables and table-like objects.
     *
     * We include system catalogs, so that we can work if a user table is
     * defined to inherit from a system catalog (pretty weird, but...)
     *
     * We ignore relations that are not ordinary tables, sequences, views,
     * materialized views, composite types, or foreign tables.
     *
     * Composite-type table entries won't be dumped as such, but we have to
     * make a DumpableObject for them so that we can track dependencies of the
     * composite type (pg_depend entries for columns of the composite type
     * link to the pg_class entry not the pg_type entry).
     *
     * Note: in this phase we should collect only a minimal amount of
     * information about each table, basically just enough to decide if it is
     * interesting. We must fetch all tables in this phase because otherwise
     * we cannot correctly identify inherited columns, owned sequences, etc.
     */

    if (fout->remoteVersion >= 90300)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any (note this dependency is AUTO as of 8.2)
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, c.relname, "
                          "c.relacl, c.relkind, c.relnamespace, "
                          "(%s c.relowner) AS rolname, "
                          "c.relchecks, c.relhastriggers, "
                          "c.relhasindex, c.relhasrules, c.relhasoids, "
                          "c.relfrozenxid, tc.oid AS toid, "
                          "tc.relfrozenxid AS tfrozenxid, "
                          "c.relpersistence, "
                          "CASE WHEN c.relkind = '%c' THEN pg_relation_is_scannable(c.oid) ELSE 't'::bool END as isscannable, "
                          "c.relpages, "
                          "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
                        "array_to_string(c.reloptions, ', ') AS reloptions, "
                          "array_to_string(array(SELECT 'toast.' || x FROM unnest(tc.reloptions) x), ', ') AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'a') "
                       "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
                   "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_MATVIEW,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE,
                          RELKIND_MATVIEW, RELKIND_FOREIGN_TABLE);
    }
    else if (fout->remoteVersion >= 90100)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any (note this dependency is AUTO as of 8.2)
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, c.relname, "
                          "c.relacl, c.relkind, c.relnamespace, "
                          "(%s c.relowner) AS rolname, "
                          "c.relchecks, c.relhastriggers, "
                          "c.relhasindex, c.relhasrules, c.relhasoids, "
                          "c.relfrozenxid, tc.oid AS toid, "
                          "tc.relfrozenxid AS tfrozenxid, "
                          "c.relpersistence, 't'::bool as isscannable, "
                          "c.relpages, "
                          "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
                        "array_to_string(c.reloptions, ', ') AS reloptions, "
                          "array_to_string(array(SELECT 'toast.' || x FROM unnest(tc.reloptions) x), ', ') AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'a') "
                       "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
                   "WHERE c.relkind in ('%c', '%c', '%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE,
                          RELKIND_MATVIEW, RELKIND_FOREIGN_TABLE);
    }
    else if (fout->remoteVersion >= 90000)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any (note this dependency is AUTO as of 8.2)
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, c.relname, "
                          "c.relacl, c.relkind, c.relnamespace, "
                          "(%s c.relowner) AS rolname, "
                          "c.relchecks, c.relhastriggers, "
                          "c.relhasindex, c.relhasrules, c.relhasoids, "
                          "c.relfrozenxid, tc.oid AS toid, "
                          "tc.relfrozenxid AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "c.relpages, "
                          "CASE WHEN c.reloftype <> 0 THEN c.reloftype::pg_catalog.regtype ELSE NULL END AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
                        "array_to_string(c.reloptions, ', ') AS reloptions, "
                          "array_to_string(array(SELECT 'toast.' || x FROM unnest(tc.reloptions) x), ', ') AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'a') "
                       "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
                          "WHERE c.relkind in ('%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE);
    }
    else if (fout->remoteVersion >= 80400)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any (note this dependency is AUTO as of 8.2)
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, c.relname, "
                          "c.relacl, c.relkind, c.relnamespace, "
                          "(%s c.relowner) AS rolname, "
                          "c.relchecks, c.relhastriggers, "
                          "c.relhasindex, c.relhasrules, c.relhasoids, "
                          "c.relfrozenxid, tc.oid AS toid, "
                          "tc.relfrozenxid AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "c.relpages, "
                          "NULL AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
                        "array_to_string(c.reloptions, ', ') AS reloptions, "
                          "array_to_string(array(SELECT 'toast.' || x FROM unnest(tc.reloptions) x), ', ') AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'a') "
                       "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
                          "WHERE c.relkind in ('%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE);
    }
    else if (fout->remoteVersion >= 80200)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any (note this dependency is AUTO as of 8.2)
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, c.relname, "
                          "c.relacl, c.relkind, c.relnamespace, "
                          "(%s c.relowner) AS rolname, "
                      "c.relchecks, (c.reltriggers <> 0) AS relhastriggers, "
                          "c.relhasindex, c.relhasrules, c.relhasoids, "
                          "c.relfrozenxid, tc.oid AS toid, "
                          "tc.relfrozenxid AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "c.relpages, "
                          "NULL AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
                        "array_to_string(c.reloptions, ', ') AS reloptions, "
                          "NULL AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'a') "
                       "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid) "
                          "WHERE c.relkind in ('%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE);
    }
    else if (fout->remoteVersion >= 80000)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, relname, "
                          "relacl, relkind, relnamespace, "
                          "(%s relowner) AS rolname, "
                          "relchecks, (reltriggers <> 0) AS relhastriggers, "
                          "relhasindex, relhasrules, relhasoids, "
                          "0 AS relfrozenxid, "
                          "0 AS toid, "
                          "0 AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "relpages, "
                          "NULL AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = c.reltablespace) AS reltablespace, "
                          "NULL AS reloptions, "
                          "NULL AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'i') "
                          "WHERE relkind in ('%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE);
    }
    else if (fout->remoteVersion >= 70300)
    {
        /*
         * Left join to pick up dependency info linking sequences to their
         * owning column, if any
         */
        appendPQExpBuffer(query,
                          "SELECT c.tableoid, c.oid, relname, "
                          "relacl, relkind, relnamespace, "
                          "(%s relowner) AS rolname, "
                          "relchecks, (reltriggers <> 0) AS relhastriggers, "
                          "relhasindex, relhasrules, relhasoids, "
                          "0 AS relfrozenxid, "
                          "0 AS toid, "
                          "0 AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "relpages, "
                          "NULL AS reloftype, "
                          "d.refobjid AS owning_tab, "
                          "d.refobjsubid AS owning_col, "
                          "NULL AS reltablespace, "
                          "NULL AS reloptions, "
                          "NULL AS toast_reloptions "
                          "FROM pg_class c "
                          "LEFT JOIN pg_depend d ON "
                          "(c.relkind = '%c' AND "
                          "d.classid = c.tableoid AND d.objid = c.oid AND "
                          "d.objsubid = 0 AND "
                          "d.refclassid = c.tableoid AND d.deptype = 'i') "
                          "WHERE relkind IN ('%c', '%c', '%c', '%c') "
                          "ORDER BY c.oid",
                          username_subquery,
                          RELKIND_SEQUENCE,
                          RELKIND_RELATION, RELKIND_SEQUENCE,
                          RELKIND_VIEW, RELKIND_COMPOSITE_TYPE);
    }
    else if (fout->remoteVersion >= 70200)
    {
        appendPQExpBuffer(query,
                          "SELECT tableoid, oid, relname, relacl, relkind, "
                          "0::oid AS relnamespace, "
                          "(%s relowner) AS rolname, "
                          "relchecks, (reltriggers <> 0) AS relhastriggers, "
                          "relhasindex, relhasrules, relhasoids, "
                          "0 AS relfrozenxid, "
                          "0 AS toid, "
                          "0 AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "relpages, "
                          "NULL AS reloftype, "
                          "NULL::oid AS owning_tab, "
                          "NULL::int4 AS owning_col, "
                          "NULL AS reltablespace, "
                          "NULL AS reloptions, "
                          "NULL AS toast_reloptions "
                          "FROM pg_class "
                          "WHERE relkind IN ('%c', '%c', '%c') "
                          "ORDER BY oid",
                          username_subquery,
                          RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW);
    }
    else if (fout->remoteVersion >= 70100)
    {
        /* all tables have oids in 7.1 */
        appendPQExpBuffer(query,
                          "SELECT tableoid, oid, relname, relacl, relkind, "
                          "0::oid AS relnamespace, "
                          "(%s relowner) AS rolname, "
                          "relchecks, (reltriggers <> 0) AS relhastriggers, "
                          "relhasindex, relhasrules, "
                          "'t'::bool AS relhasoids, "
                          "0 AS relfrozenxid, "
                          "0 AS toid, "
                          "0 AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "relpages, "
                          "NULL AS reloftype, "
                          "NULL::oid AS owning_tab, "
                          "NULL::int4 AS owning_col, "
                          "NULL AS reltablespace, "
                          "NULL AS reloptions, "
                          "NULL AS toast_reloptions "
                          "FROM pg_class "
                          "WHERE relkind IN ('%c', '%c', '%c') "
                          "ORDER BY oid",
                          username_subquery,
                          RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW);
    }
    else
    {
        /*
         * Before 7.1, view relkind was not set to 'v', so we must check if we
         * have a view by looking for a rule in pg_rewrite.
         */
        appendPQExpBuffer(query,
                          "SELECT "
        "(SELECT oid FROM pg_class WHERE relname = 'pg_class') AS tableoid, "
                          "oid, relname, relacl, "
                          "CASE WHEN relhasrules and relkind = 'r' "
                      "  and EXISTS(SELECT rulename FROM pg_rewrite r WHERE "
                      "             r.ev_class = c.oid AND r.ev_type = '1') "
                          "THEN '%c'::\"char\" "
                          "ELSE relkind END AS relkind,"
                          "0::oid AS relnamespace, "
                          "(%s relowner) AS rolname, "
                          "relchecks, (reltriggers <> 0) AS relhastriggers, "
                          "relhasindex, relhasrules, "
                          "'t'::bool AS relhasoids, "
                          "0 as relfrozenxid, "
                          "0 AS toid, "
                          "0 AS tfrozenxid, "
                          "'p' AS relpersistence, 't'::bool as isscannable, "
                          "0 AS relpages, "
                          "NULL AS reloftype, "
                          "NULL::oid AS owning_tab, "
                          "NULL::int4 AS owning_col, "
                          "NULL AS reltablespace, "
                          "NULL AS reloptions, "
                          "NULL AS toast_reloptions "
                          "FROM pg_class c "
                          "WHERE relkind IN ('%c', '%c') "
                          "ORDER BY oid",
                          RELKIND_VIEW,
                          username_subquery,
                          RELKIND_RELATION, RELKIND_SEQUENCE);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

    *numTables = ntups;

    /*
     * Extract data from result and lock dumpable tables.  We do the locking
     * before anything else, to minimize the window wherein a table could
     * disappear under us.
     *
     * Note that we have to save info about all tables here, even when dumping
     * only one, because we don't yet know which tables might be inheritance
     * ancestors of the target table.
     */
    tblinfo = (TableInfo *) pg_malloc0(ntups * sizeof(TableInfo));

    i_reltableoid = PQfnumber(res, "tableoid");
    i_reloid = PQfnumber(res, "oid");
    i_relname = PQfnumber(res, "relname");
    i_relnamespace = PQfnumber(res, "relnamespace");
    i_relacl = PQfnumber(res, "relacl");
    i_relkind = PQfnumber(res, "relkind");
    i_rolname = PQfnumber(res, "rolname");
    i_relchecks = PQfnumber(res, "relchecks");
    i_relhastriggers = PQfnumber(res, "relhastriggers");
    i_relhasindex = PQfnumber(res, "relhasindex");
    i_relhasrules = PQfnumber(res, "relhasrules");
    i_relhasoids = PQfnumber(res, "relhasoids");
    i_relfrozenxid = PQfnumber(res, "relfrozenxid");
    i_toastoid = PQfnumber(res, "toid");
    i_toastfrozenxid = PQfnumber(res, "tfrozenxid");
    i_relpersistence = PQfnumber(res, "relpersistence");
    i_isscannable = PQfnumber(res, "isscannable");
    i_relpages = PQfnumber(res, "relpages");
    i_owning_tab = PQfnumber(res, "owning_tab");
    i_owning_col = PQfnumber(res, "owning_col");
    i_reltablespace = PQfnumber(res, "reltablespace");
    i_reloptions = PQfnumber(res, "reloptions");
    i_toastreloptions = PQfnumber(res, "toast_reloptions");
    i_reloftype = PQfnumber(res, "reloftype");

    if (lockWaitTimeout && fout->remoteVersion >= 70300)
    {
        /*
         * Arrange to fail instead of waiting forever for a table lock.
         *
         * NB: this coding assumes that the only queries issued within the
         * following loop are LOCK TABLEs; else the timeout may be undesirably
         * applied to other things too.
         */
        resetPQExpBuffer(query);
        appendPQExpBuffer(query, "SET statement_timeout = ");
        appendStringLiteralConn(query, lockWaitTimeout, GetConnection(fout));
        ExecuteSqlStatement(fout, query->data);
    }

    for (i = 0; i < ntups; i++)
    {
        tblinfo[i].dobj.objType = DO_TABLE;
        tblinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_reltableoid));
        tblinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_reloid));
        AssignDumpId(&tblinfo[i].dobj);
        tblinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_relname));
        tblinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_relnamespace)),
                          tblinfo[i].dobj.catId.oid);
        tblinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        tblinfo[i].relacl = pg_strdup(PQgetvalue(res, i, i_relacl));
        tblinfo[i].relkind = *(PQgetvalue(res, i, i_relkind));
        tblinfo[i].relpersistence = *(PQgetvalue(res, i, i_relpersistence));
        tblinfo[i].hasindex = (strcmp(PQgetvalue(res, i, i_relhasindex), "t") == 0);
        tblinfo[i].hasrules = (strcmp(PQgetvalue(res, i, i_relhasrules), "t") == 0);
        tblinfo[i].hastriggers = (strcmp(PQgetvalue(res, i, i_relhastriggers), "t") == 0);
        tblinfo[i].hasoids = (strcmp(PQgetvalue(res, i, i_relhasoids), "t") == 0);
        tblinfo[i].isscannable = (strcmp(PQgetvalue(res, i, i_isscannable), "t") == 0);
        tblinfo[i].relpages = atoi(PQgetvalue(res, i, i_relpages));
        tblinfo[i].frozenxid = atooid(PQgetvalue(res, i, i_relfrozenxid));
        tblinfo[i].toast_oid = atooid(PQgetvalue(res, i, i_toastoid));
        tblinfo[i].toast_frozenxid = atooid(PQgetvalue(res, i, i_toastfrozenxid));
        if (PQgetisnull(res, i, i_reloftype))
            tblinfo[i].reloftype = NULL;
        else
            tblinfo[i].reloftype = pg_strdup(PQgetvalue(res, i, i_reloftype));
        tblinfo[i].ncheck = atoi(PQgetvalue(res, i, i_relchecks));
        if (PQgetisnull(res, i, i_owning_tab))
        {
            tblinfo[i].owning_tab = InvalidOid;
            tblinfo[i].owning_col = 0;
        }
        else
        {
            tblinfo[i].owning_tab = atooid(PQgetvalue(res, i, i_owning_tab));
            tblinfo[i].owning_col = atoi(PQgetvalue(res, i, i_owning_col));
        }
        tblinfo[i].reltablespace = pg_strdup(PQgetvalue(res, i, i_reltablespace));
        tblinfo[i].reloptions = pg_strdup(PQgetvalue(res, i, i_reloptions));
        tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));

        /* other fields were zeroed above */

        /*
         * Decide whether we want to dump this table.
         */
        if (tblinfo[i].relkind == RELKIND_COMPOSITE_TYPE)
            tblinfo[i].dobj.dump = false;
        else
            selectDumpableTable(&tblinfo[i]);
        tblinfo[i].interesting = tblinfo[i].dobj.dump;

        /*
         * Read-lock target tables to make sure they aren't DROPPED or altered
         * in schema before we get around to dumping them.
         *
         * Note that we don't explicitly lock parents of the target tables; we
         * assume our lock on the child is enough to prevent schema
         * alterations to parent tables.
         *
         * NOTE: it'd be kinda nice to lock other relations too, not only
         * plain tables, but the backend doesn't presently allow that.
         */
        if (tblinfo[i].dobj.dump && tblinfo[i].relkind == RELKIND_RELATION)
        {
            resetPQExpBuffer(query);
            appendPQExpBuffer(query,
                              "LOCK TABLE %s IN ACCESS SHARE MODE",
                              fmtQualifiedId(fout->remoteVersion,
                                        tblinfo[i].dobj.namespace->dobj.name,
                                             tblinfo[i].dobj.name));
            ExecuteSqlStatement(fout, query->data);
        }

        /* Emit notice if join for owner failed */
        if (strlen(tblinfo[i].rolname) == 0)
            write_msg(NULL, "WARNING: owner of table \"%s\" appears to be invalid\n",
                      tblinfo[i].dobj.name);
    }

    if (lockWaitTimeout && fout->remoteVersion >= 70300)
    {
        ExecuteSqlStatement(fout, "SET statement_timeout = 0");
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return tblinfo;
}

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

Definition at line 5525 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _triggerInfo::dobj, _tableInfo::dobj, _dumpableObject::dump, ExecuteSqlQuery(), exit_horribly(), g_verbose, _tableInfo::hastriggers, i, _dumpableObject::name, NULL, _dumpableObject::objType, CatalogId::oid, OidIsValid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), PQntuples(), Archive::remoteVersion, resetPQExpBuffer(), selectSourceSchema(), CatalogId::tableoid, _triggerInfo::tgargs, _triggerInfo::tgconstrname, _triggerInfo::tgconstrrelid, _triggerInfo::tgconstrrelname, _triggerInfo::tgdef, _triggerInfo::tgdeferrable, _triggerInfo::tgenabled, _triggerInfo::tgfname, _triggerInfo::tginitdeferred, _triggerInfo::tgisconstraint, _triggerInfo::tgnargs, _triggerInfo::tgtable, _triggerInfo::tgtype, and write_msg().

Referenced by getSchemaData().

{
    int         i,
                j;
    PQExpBuffer query = createPQExpBuffer();
    PGresult   *res;
    TriggerInfo *tginfo;
    int         i_tableoid,
                i_oid,
                i_tgname,
                i_tgfname,
                i_tgtype,
                i_tgnargs,
                i_tgargs,
                i_tgisconstraint,
                i_tgconstrname,
                i_tgconstrrelid,
                i_tgconstrrelname,
                i_tgenabled,
                i_tgdeferrable,
                i_tginitdeferred,
                i_tgdef;
    int         ntups;

    for (i = 0; i < numTables; i++)
    {
        TableInfo  *tbinfo = &tblinfo[i];

        if (!tbinfo->hastriggers || !tbinfo->dobj.dump)
            continue;

        if (g_verbose)
            write_msg(NULL, "reading triggers for table \"%s\"\n",
                      tbinfo->dobj.name);

        /*
         * select table schema to ensure regproc name is qualified if needed
         */
        selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);

        resetPQExpBuffer(query);
        if (fout->remoteVersion >= 90000)
        {
            /*
             * NB: think not to use pretty=true in pg_get_triggerdef.  It
             * could result in non-forward-compatible dumps of WHEN clauses
             * due to under-parenthesization.
             */
            appendPQExpBuffer(query,
                              "SELECT tgname, "
                              "tgfoid::pg_catalog.regproc AS tgfname, "
                        "pg_catalog.pg_get_triggerdef(oid, false) AS tgdef, "
                              "tgenabled, tableoid, oid "
                              "FROM pg_catalog.pg_trigger t "
                              "WHERE tgrelid = '%u'::pg_catalog.oid "
                              "AND NOT tgisinternal",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 80300)
        {
            /*
             * We ignore triggers that are tied to a foreign-key constraint
             */
            appendPQExpBuffer(query,
                              "SELECT tgname, "
                              "tgfoid::pg_catalog.regproc AS tgfname, "
                              "tgtype, tgnargs, tgargs, tgenabled, "
                              "tgisconstraint, tgconstrname, tgdeferrable, "
                              "tgconstrrelid, tginitdeferred, tableoid, oid, "
                     "tgconstrrelid::pg_catalog.regclass AS tgconstrrelname "
                              "FROM pg_catalog.pg_trigger t "
                              "WHERE tgrelid = '%u'::pg_catalog.oid "
                              "AND tgconstraint = 0",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 70300)
        {
            /*
             * We ignore triggers that are tied to a foreign-key constraint,
             * but in these versions we have to grovel through pg_constraint
             * to find out
             */
            appendPQExpBuffer(query,
                              "SELECT tgname, "
                              "tgfoid::pg_catalog.regproc AS tgfname, "
                              "tgtype, tgnargs, tgargs, tgenabled, "
                              "tgisconstraint, tgconstrname, tgdeferrable, "
                              "tgconstrrelid, tginitdeferred, tableoid, oid, "
                     "tgconstrrelid::pg_catalog.regclass AS tgconstrrelname "
                              "FROM pg_catalog.pg_trigger t "
                              "WHERE tgrelid = '%u'::pg_catalog.oid "
                              "AND (NOT tgisconstraint "
                              " OR NOT EXISTS"
                              "  (SELECT 1 FROM pg_catalog.pg_depend d "
                              "   JOIN pg_catalog.pg_constraint c ON (d.refclassid = c.tableoid AND d.refobjid = c.oid) "
                              "   WHERE d.classid = t.tableoid AND d.objid = t.oid AND d.deptype = 'i' AND c.contype = 'f'))",
                              tbinfo->dobj.catId.oid);
        }
        else if (fout->remoteVersion >= 70100)
        {
            appendPQExpBuffer(query,
                              "SELECT tgname, tgfoid::regproc AS tgfname, "
                              "tgtype, tgnargs, tgargs, tgenabled, "
                              "tgisconstraint, tgconstrname, tgdeferrable, "
                              "tgconstrrelid, tginitdeferred, tableoid, oid, "
                  "(SELECT relname FROM pg_class WHERE oid = tgconstrrelid) "
                              "     AS tgconstrrelname "
                              "FROM pg_trigger "
                              "WHERE tgrelid = '%u'::oid",
                              tbinfo->dobj.catId.oid);
        }
        else
        {
            appendPQExpBuffer(query,
                              "SELECT tgname, tgfoid::regproc AS tgfname, "
                              "tgtype, tgnargs, tgargs, tgenabled, "
                              "tgisconstraint, tgconstrname, tgdeferrable, "
                              "tgconstrrelid, tginitdeferred, "
                              "(SELECT oid FROM pg_class WHERE relname = 'pg_trigger') AS tableoid, "
                              "oid, "
                  "(SELECT relname FROM pg_class WHERE oid = tgconstrrelid) "
                              "     AS tgconstrrelname "
                              "FROM pg_trigger "
                              "WHERE tgrelid = '%u'::oid",
                              tbinfo->dobj.catId.oid);
        }
        res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

        ntups = PQntuples(res);

        i_tableoid = PQfnumber(res, "tableoid");
        i_oid = PQfnumber(res, "oid");
        i_tgname = PQfnumber(res, "tgname");
        i_tgfname = PQfnumber(res, "tgfname");
        i_tgtype = PQfnumber(res, "tgtype");
        i_tgnargs = PQfnumber(res, "tgnargs");
        i_tgargs = PQfnumber(res, "tgargs");
        i_tgisconstraint = PQfnumber(res, "tgisconstraint");
        i_tgconstrname = PQfnumber(res, "tgconstrname");
        i_tgconstrrelid = PQfnumber(res, "tgconstrrelid");
        i_tgconstrrelname = PQfnumber(res, "tgconstrrelname");
        i_tgenabled = PQfnumber(res, "tgenabled");
        i_tgdeferrable = PQfnumber(res, "tgdeferrable");
        i_tginitdeferred = PQfnumber(res, "tginitdeferred");
        i_tgdef = PQfnumber(res, "tgdef");

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

        for (j = 0; j < ntups; j++)
        {
            tginfo[j].dobj.objType = DO_TRIGGER;
            tginfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
            tginfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
            AssignDumpId(&tginfo[j].dobj);
            tginfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_tgname));
            tginfo[j].dobj.namespace = tbinfo->dobj.namespace;
            tginfo[j].tgtable = tbinfo;
            tginfo[j].tgenabled = *(PQgetvalue(res, j, i_tgenabled));
            if (i_tgdef >= 0)
            {
                tginfo[j].tgdef = pg_strdup(PQgetvalue(res, j, i_tgdef));

                /* remaining fields are not valid if we have tgdef */
                tginfo[j].tgfname = NULL;
                tginfo[j].tgtype = 0;
                tginfo[j].tgnargs = 0;
                tginfo[j].tgargs = NULL;
                tginfo[j].tgisconstraint = false;
                tginfo[j].tgdeferrable = false;
                tginfo[j].tginitdeferred = false;
                tginfo[j].tgconstrname = NULL;
                tginfo[j].tgconstrrelid = InvalidOid;
                tginfo[j].tgconstrrelname = NULL;
            }
            else
            {
                tginfo[j].tgdef = NULL;

                tginfo[j].tgfname = pg_strdup(PQgetvalue(res, j, i_tgfname));
                tginfo[j].tgtype = atoi(PQgetvalue(res, j, i_tgtype));
                tginfo[j].tgnargs = atoi(PQgetvalue(res, j, i_tgnargs));
                tginfo[j].tgargs = pg_strdup(PQgetvalue(res, j, i_tgargs));
                tginfo[j].tgisconstraint = *(PQgetvalue(res, j, i_tgisconstraint)) == 't';
                tginfo[j].tgdeferrable = *(PQgetvalue(res, j, i_tgdeferrable)) == 't';
                tginfo[j].tginitdeferred = *(PQgetvalue(res, j, i_tginitdeferred)) == 't';

                if (tginfo[j].tgisconstraint)
                {
                    tginfo[j].tgconstrname = pg_strdup(PQgetvalue(res, j, i_tgconstrname));
                    tginfo[j].tgconstrrelid = atooid(PQgetvalue(res, j, i_tgconstrrelid));
                    if (OidIsValid(tginfo[j].tgconstrrelid))
                    {
                        if (PQgetisnull(res, j, i_tgconstrrelname))
                            exit_horribly(NULL, "query produced null referenced table name for foreign key trigger \"%s\" on table \"%s\" (OID of table: %u)\n",
                                          tginfo[j].dobj.name,
                                          tbinfo->dobj.name,
                                          tginfo[j].tgconstrrelid);
                        tginfo[j].tgconstrrelname = pg_strdup(PQgetvalue(res, j, i_tgconstrrelname));
                    }
                    else
                        tginfo[j].tgconstrrelname = NULL;
                }
                else
                {
                    tginfo[j].tgconstrname = NULL;
                    tginfo[j].tgconstrrelid = InvalidOid;
                    tginfo[j].tgconstrrelname = NULL;
                }
            }
        }

        PQclear(res);
    }

    destroyPQExpBuffer(query);
}

TSConfigInfo* getTSConfigurations ( Archive fout,
int *  numTSConfigs 
)

Definition at line 6950 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, _cfgInfo::cfgparser, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _cfgInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _cfgInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    TSConfigInfo *cfginfo;
    int         i_tableoid;
    int         i_oid;
    int         i_cfgname;
    int         i_cfgnamespace;
    int         i_rolname;
    int         i_cfgparser;

    /* Before 8.3, there is no built-in text search support */
    if (fout->remoteVersion < 80300)
    {
        *numTSConfigs = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, cfgname, "
                      "cfgnamespace, (%s cfgowner) AS rolname, cfgparser "
                      "FROM pg_ts_config",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numTSConfigs = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_cfgname = PQfnumber(res, "cfgname");
    i_cfgnamespace = PQfnumber(res, "cfgnamespace");
    i_rolname = PQfnumber(res, "rolname");
    i_cfgparser = PQfnumber(res, "cfgparser");

    for (i = 0; i < ntups; i++)
    {
        cfginfo[i].dobj.objType = DO_TSCONFIG;
        cfginfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        cfginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&cfginfo[i].dobj);
        cfginfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_cfgname));
        cfginfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_cfgnamespace)),
                          cfginfo[i].dobj.catId.oid);
        cfginfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        cfginfo[i].cfgparser = atooid(PQgetvalue(res, i, i_cfgparser));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(cfginfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return cfginfo;
}

TSDictInfo* getTSDictionaries ( Archive fout,
int *  numTSDicts 
)

Definition at line 6788 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _dictInfo::dictinitoption, _dictInfo::dicttemplate, _dictInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetisnull(), PQgetvalue(), PQntuples(), Archive::remoteVersion, _dictInfo::rolname, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, and username_subquery.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    TSDictInfo *dictinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_dictname;
    int         i_dictnamespace;
    int         i_rolname;
    int         i_dicttemplate;
    int         i_dictinitoption;

    /* Before 8.3, there is no built-in text search support */
    if (fout->remoteVersion < 80300)
    {
        *numTSDicts = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, dictname, "
                      "dictnamespace, (%s dictowner) AS rolname, "
                      "dicttemplate, dictinitoption "
                      "FROM pg_ts_dict",
                      username_subquery);

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numTSDicts = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_dictname = PQfnumber(res, "dictname");
    i_dictnamespace = PQfnumber(res, "dictnamespace");
    i_rolname = PQfnumber(res, "rolname");
    i_dictinitoption = PQfnumber(res, "dictinitoption");
    i_dicttemplate = PQfnumber(res, "dicttemplate");

    for (i = 0; i < ntups; i++)
    {
        dictinfo[i].dobj.objType = DO_TSDICT;
        dictinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        dictinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&dictinfo[i].dobj);
        dictinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_dictname));
        dictinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_dictnamespace)),
                          dictinfo[i].dobj.catId.oid);
        dictinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        dictinfo[i].dicttemplate = atooid(PQgetvalue(res, i, i_dicttemplate));
        if (PQgetisnull(res, i, i_dictinitoption))
            dictinfo[i].dictinitoption = NULL;
        else
            dictinfo[i].dictinitoption = pg_strdup(PQgetvalue(res, i, i_dictinitoption));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(dictinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return dictinfo;
}

TSParserInfo* getTSParsers ( Archive fout,
int *  numTSParsers 
)

Definition at line 6696 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _prsInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), _prsInfo::prsend, _prsInfo::prsheadline, _prsInfo::prslextype, _prsInfo::prsstart, _prsInfo::prstoken, Archive::remoteVersion, selectDumpableObject(), selectSourceSchema(), and CatalogId::tableoid.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    TSParserInfo *prsinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_prsname;
    int         i_prsnamespace;
    int         i_prsstart;
    int         i_prstoken;
    int         i_prsend;
    int         i_prsheadline;
    int         i_prslextype;

    /* Before 8.3, there is no built-in text search support */
    if (fout->remoteVersion < 80300)
    {
        *numTSParsers = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /*
     * find all text search objects, including builtin ones; we filter out
     * system-defined objects at dump-out time.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, prsname, prsnamespace, "
                      "prsstart::oid, prstoken::oid, "
                      "prsend::oid, prsheadline::oid, prslextype::oid "
                      "FROM pg_ts_parser");

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numTSParsers = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_prsname = PQfnumber(res, "prsname");
    i_prsnamespace = PQfnumber(res, "prsnamespace");
    i_prsstart = PQfnumber(res, "prsstart");
    i_prstoken = PQfnumber(res, "prstoken");
    i_prsend = PQfnumber(res, "prsend");
    i_prsheadline = PQfnumber(res, "prsheadline");
    i_prslextype = PQfnumber(res, "prslextype");

    for (i = 0; i < ntups; i++)
    {
        prsinfo[i].dobj.objType = DO_TSPARSER;
        prsinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        prsinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&prsinfo[i].dobj);
        prsinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_prsname));
        prsinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_prsnamespace)),
                          prsinfo[i].dobj.catId.oid);
        prsinfo[i].prsstart = atooid(PQgetvalue(res, i, i_prsstart));
        prsinfo[i].prstoken = atooid(PQgetvalue(res, i, i_prstoken));
        prsinfo[i].prsend = atooid(PQgetvalue(res, i, i_prsend));
        prsinfo[i].prsheadline = atooid(PQgetvalue(res, i, i_prsheadline));
        prsinfo[i].prslextype = atooid(PQgetvalue(res, i, i_prslextype));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(prsinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return prsinfo;
}

TSTemplateInfo* getTSTemplates ( Archive fout,
int *  numTSTemplates 
)

Definition at line 6873 of file pg_dump.c.

References appendPQExpBuffer(), AssignDumpId(), atooid, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _tmplInfo::dobj, ExecuteSqlQuery(), findNamespace(), i, _dumpableObject::name, _dumpableObject::objType, CatalogId::oid, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectDumpableObject(), selectSourceSchema(), CatalogId::tableoid, _tmplInfo::tmplinit, and _tmplInfo::tmpllexize.

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query;
    TSTemplateInfo *tmplinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_tmplname;
    int         i_tmplnamespace;
    int         i_tmplinit;
    int         i_tmpllexize;

    /* Before 8.3, there is no built-in text search support */
    if (fout->remoteVersion < 80300)
    {
        *numTSTemplates = 0;
        return NULL;
    }

    query = createPQExpBuffer();

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    appendPQExpBuffer(query, "SELECT tableoid, oid, tmplname, "
                      "tmplnamespace, tmplinit::oid, tmpllexize::oid "
                      "FROM pg_ts_template");

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);
    *numTSTemplates = ntups;

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_tmplname = PQfnumber(res, "tmplname");
    i_tmplnamespace = PQfnumber(res, "tmplnamespace");
    i_tmplinit = PQfnumber(res, "tmplinit");
    i_tmpllexize = PQfnumber(res, "tmpllexize");

    for (i = 0; i < ntups; i++)
    {
        tmplinfo[i].dobj.objType = DO_TSTEMPLATE;
        tmplinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        tmplinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&tmplinfo[i].dobj);
        tmplinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_tmplname));
        tmplinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_tmplnamespace)),
                          tmplinfo[i].dobj.catId.oid);
        tmplinfo[i].tmplinit = atooid(PQgetvalue(res, i, i_tmplinit));
        tmplinfo[i].tmpllexize = atooid(PQgetvalue(res, i, i_tmpllexize));

        /* Decide whether we want to dump it */
        selectDumpableObject(&(tmplinfo[i].dobj));
    }

    PQclear(res);

    destroyPQExpBuffer(query);

    return tmplinfo;
}

TypeInfo* getTypes ( Archive fout,
int *  numTypes 
)

Definition at line 3109 of file pg_dump.c.

References addObjectDependency(), appendPQExpBuffer(), AssignDumpId(), atooid, _shellTypeInfo::baseType, _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), _funcInfo::dobj, _shellTypeInfo::dobj, _dumpableObject::dump, _dumpableObject::dumpId, ExecuteSqlQuery(), findFuncByOid(), findNamespace(), getDomainConstraints(), i, _dumpableObject::name, NULL, _dumpableObject::objType, pg_malloc(), pg_strdup(), PGRES_TUPLES_OK, PQclear(), PQfnumber(), PQgetvalue(), PQntuples(), Archive::remoteVersion, selectDumpableType(), selectSourceSchema(), TYPTYPE_BASE, TYPTYPE_DOMAIN, TYPTYPE_RANGE, username_subquery, and write_msg().

Referenced by getSchemaData().

{
    PGresult   *res;
    int         ntups;
    int         i;
    PQExpBuffer query = createPQExpBuffer();
    TypeInfo   *tyinfo;
    ShellTypeInfo *stinfo;
    int         i_tableoid;
    int         i_oid;
    int         i_typname;
    int         i_typnamespace;
    int         i_typacl;
    int         i_rolname;
    int         i_typinput;
    int         i_typoutput;
    int         i_typelem;
    int         i_typrelid;
    int         i_typrelkind;
    int         i_typtype;
    int         i_typisdefined;
    int         i_isarray;

    /*
     * we include even the built-in types because those may be used as array
     * elements by user-defined types
     *
     * we filter out the built-in types when we dump out the types
     *
     * same approach for undefined (shell) types and array types
     *
     * Note: as of 8.3 we can reliably detect whether a type is an
     * auto-generated array type by checking the element type's typarray.
     * (Before that the test is capable of generating false positives.) We
     * still check for name beginning with '_', though, so as to avoid the
     * cost of the subselect probe for all standard types.  This would have to
     * be revisited if the backend ever allows renaming of array types.
     */

    /* Make sure we are in proper schema */
    selectSourceSchema(fout, "pg_catalog");

    if (fout->remoteVersion >= 90200)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, typname, "
                          "typnamespace, typacl, "
                          "(%s typowner) AS rolname, "
                          "typinput::oid AS typinput, "
                          "typoutput::oid AS typoutput, typelem, typrelid, "
                          "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
                          "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
                          "typtype, typisdefined, "
                          "typname[0] = '_' AND typelem != 0 AND "
                          "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
                          "FROM pg_type",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 80300)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, typname, "
                          "typnamespace, '{=U}' AS typacl, "
                          "(%s typowner) AS rolname, "
                          "typinput::oid AS typinput, "
                          "typoutput::oid AS typoutput, typelem, typrelid, "
                          "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
                          "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
                          "typtype, typisdefined, "
                          "typname[0] = '_' AND typelem != 0 AND "
                          "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
                          "FROM pg_type",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70300)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, typname, "
                          "typnamespace, '{=U}' AS typacl, "
                          "(%s typowner) AS rolname, "
                          "typinput::oid AS typinput, "
                          "typoutput::oid AS typoutput, typelem, typrelid, "
                          "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
                          "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
                          "typtype, typisdefined, "
                          "typname[0] = '_' AND typelem != 0 AS isarray "
                          "FROM pg_type",
                          username_subquery);
    }
    else if (fout->remoteVersion >= 70100)
    {
        appendPQExpBuffer(query, "SELECT tableoid, oid, typname, "
                          "0::oid AS typnamespace, '{=U}' AS typacl, "
                          "(%s typowner) AS rolname, "
                          "typinput::oid AS typinput, "
                          "typoutput::oid AS typoutput, typelem, typrelid, "
                          "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
                          "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
                          "typtype, typisdefined, "
                          "typname[0] = '_' AND typelem != 0 AS isarray "
                          "FROM pg_type",
                          username_subquery);
    }
    else
    {
        appendPQExpBuffer(query, "SELECT "
         "(SELECT oid FROM pg_class WHERE relname = 'pg_type') AS tableoid, "
                          "oid, typname, "
                          "0::oid AS typnamespace, '{=U}' AS typacl, "
                          "(%s typowner) AS rolname, "
                          "typinput::oid AS typinput, "
                          "typoutput::oid AS typoutput, typelem, typrelid, "
                          "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
                          "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
                          "typtype, typisdefined, "
                          "typname[0] = '_' AND typelem != 0 AS isarray "
                          "FROM pg_type",
                          username_subquery);
    }

    res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);

    ntups = PQntuples(res);

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

    i_tableoid = PQfnumber(res, "tableoid");
    i_oid = PQfnumber(res, "oid");
    i_typname = PQfnumber(res, "typname");
    i_typnamespace = PQfnumber(res, "typnamespace");
    i_typacl = PQfnumber(res, "typacl");
    i_rolname = PQfnumber(res, "rolname");
    i_typinput = PQfnumber(res, "typinput");
    i_typoutput = PQfnumber(res, "typoutput");
    i_typelem = PQfnumber(res, "typelem");
    i_typrelid = PQfnumber(res, "typrelid");
    i_typrelkind = PQfnumber(res, "typrelkind");
    i_typtype = PQfnumber(res, "typtype");
    i_typisdefined = PQfnumber(res, "typisdefined");
    i_isarray = PQfnumber(res, "isarray");

    for (i = 0; i < ntups; i++)
    {
        tyinfo[i].dobj.objType = DO_TYPE;
        tyinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
        tyinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
        AssignDumpId(&tyinfo[i].dobj);
        tyinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_typname));
        tyinfo[i].dobj.namespace =
            findNamespace(fout,
                          atooid(PQgetvalue(res, i, i_typnamespace)),
                          tyinfo[i].dobj.catId.oid);
        tyinfo[i].rolname = pg_strdup(PQgetvalue(res, i, i_rolname));
        tyinfo[i].typacl = pg_strdup(PQgetvalue(res, i, i_typacl));
        tyinfo[i].typelem = atooid(PQgetvalue(res, i, i_typelem));
        tyinfo[i].typrelid = atooid(PQgetvalue(res, i, i_typrelid));
        tyinfo[i].typrelkind = *PQgetvalue(res, i, i_typrelkind);
        tyinfo[i].typtype = *PQgetvalue(res, i, i_typtype);
        tyinfo[i].shellType = NULL;

        if (strcmp(PQgetvalue(res, i, i_typisdefined), "t") == 0)
            tyinfo[i].isDefined = true;
        else
            tyinfo[i].isDefined = false;

        if (strcmp(PQgetvalue(res, i, i_isarray), "t") == 0)
            tyinfo[i].isArray = true;
        else
            tyinfo[i].isArray = false;

        /* Decide whether we want to dump it */
        selectDumpableType(&tyinfo[i]);

        /*
         * If it's a domain, fetch info about its constraints, if any
         */
        tyinfo[i].nDomChecks = 0;
        tyinfo[i].domChecks = NULL;
        if (tyinfo[i].dobj.dump && tyinfo[i].typtype == TYPTYPE_DOMAIN)
            getDomainConstraints(fout, &(tyinfo[i]));

        /*
         * If it's a base type, make a DumpableObject representing a shell
         * definition of the type.  We will need to dump that ahead of the I/O
         * functions for the type.  Similarly, range types need a shell
         * definition in case they have a canonicalize function.
         *
         * Note: the shell type doesn't have a catId.  You might think it
         * should copy the base type's catId, but then it might capture the
         * pg_depend entries for the type, which we don't want.
         */
        if (tyinfo[i].dobj.dump && (tyinfo[i].typtype == TYPTYPE_BASE ||
                                    tyinfo[i].typtype == TYPTYPE_RANGE))
        {
            stinfo = (ShellTypeInfo *) pg_malloc(sizeof(ShellTypeInfo));
            stinfo->dobj.objType = DO_SHELL_TYPE;
            stinfo->dobj.catId = nilCatalogId;
            AssignDumpId(&stinfo->dobj);
            stinfo->dobj.name = pg_strdup(tyinfo[i].dobj.name);
            stinfo->dobj.namespace = tyinfo[i].dobj.namespace;
            stinfo->baseType = &(tyinfo[i]);
            tyinfo[i].shellType = stinfo;

            /*
             * Initially mark the shell type as not to be dumped.  We'll only
             * dump it if the I/O or canonicalize functions need to be dumped;
             * this is taken care of while sorting dependencies.
             */
            stinfo->dobj.dump = false;

            /*
             * However, if dumping from pre-7.3, there will be no dependency
             * info so we have to fake it here.  We only need to worry about
             * typinput and typoutput since the other functions only exist
             * post-7.3.
             */
            if (fout->remoteVersion < 70300)
            {
                Oid         typinput;
                Oid         typoutput;
                FuncInfo   *funcInfo;

                typinput = atooid(PQgetvalue(res, i, i_typinput));
                typoutput = atooid(PQgetvalue(res, i, i_typoutput));

                funcInfo = findFuncByOid(typinput);
                if (funcInfo && funcInfo->dobj.dump)
                {
                    /* base type depends on function */
                    addObjectDependency(&tyinfo[i].dobj,
                                        funcInfo->dobj.dumpId);
                    /* function depends on shell type */
                    addObjectDependency(&funcInfo->dobj,
                                        stinfo->dobj.dumpId);
                    /* mark shell type as to be dumped */
                    stinfo->dobj.dump = true;
                }

                funcInfo = findFuncByOid(typoutput);
                if (funcInfo && funcInfo->dobj.dump)
                {
                    /* base type depends on function */
                    addObjectDependency(&tyinfo[i].dobj,
                                        funcInfo->dobj.dumpId);
                    /* function depends on shell type */
                    addObjectDependency(&funcInfo->dobj,
                                        stinfo->dobj.dumpId);
                    /* mark shell type as to be dumped */
                    stinfo->dobj.dump = true;
                }
            }
        }

        if (strlen(tyinfo[i].rolname) == 0 && tyinfo[i].isDefined)
            write_msg(NULL, "WARNING: owner of data type \"%s\" appears to be invalid\n",
                      tyinfo[i].dobj.name);
    }

    *numTypes = ntups;

    PQclear(res);

    destroyPQExpBuffer(query);

    return tyinfo;
}

static void guessConstraintInheritance ( TableInfo tblinfo,
int  numTables 
) [static]

Definition at line 2044 of file pg_dump.c.

References _tableInfo::checkexprs, _constraintInfo::conislocal, _constraintInfo::dobj, _tableInfo::dobj, _dumpableObject::dump, i, _dumpableObject::name, _tableInfo::ncheck, _tableInfo::numParents, _tableInfo::parents, _tableInfo::relkind, RELKIND_SEQUENCE, and RELKIND_VIEW.

Referenced by main().

{
    int         i,
                j,
                k;

    for (i = 0; i < numTables; i++)
    {
        TableInfo  *tbinfo = &(tblinfo[i]);
        int         numParents;
        TableInfo **parents;
        TableInfo  *parent;

        /* Sequences and views never have parents */
        if (tbinfo->relkind == RELKIND_SEQUENCE ||
            tbinfo->relkind == RELKIND_VIEW)
            continue;

        /* Don't bother computing anything for non-target tables, either */
        if (!tbinfo->dobj.dump)
            continue;

        numParents = tbinfo->numParents;
        parents = tbinfo->parents;

        if (numParents == 0)
            continue;           /* nothing to see here, move along */

        /* scan for inherited CHECK constraints */
        for (j = 0; j < tbinfo->ncheck; j++)
        {
            ConstraintInfo *constr;

            constr = &(tbinfo->checkexprs[j]);

            for (k = 0; k < numParents; k++)
            {
                int         l;

                parent = parents[k];
                for (l = 0; l < parent->ncheck; l++)
                {
                    ConstraintInfo *pconstr = &(parent->checkexprs[l]);

                    if (strcmp(pconstr->dobj.name, constr->dobj.name) == 0)
                    {
                        constr->conislocal = false;
                        break;
                    }
                }
                if (!constr->conislocal)
                    break;
            }
        }
    }
}

static void help ( const char *  progname  )  [static]

Definition at line 854 of file pg_dump.c.

References _.

Referenced by main().

{
    printf(_("%s dumps a database as a text file or to other formats.\n\n"), progname);
    printf(_("Usage:\n"));
    printf(_("  %s [OPTION]... [DBNAME]\n"), progname);

    printf(_("\nGeneral options:\n"));
    printf(_("  -f, --file=FILENAME          output file or directory name\n"));
    printf(_("  -F, --format=c|d|t|p         output file format (custom, directory, tar,\n"
             "                               plain text (default))\n"));
    printf(_("  -j, --jobs=NUM               use this many parallel jobs to dump\n"));
    printf(_("  -v, --verbose                verbose mode\n"));
    printf(_("  -V, --version                output version information, then exit\n"));
    printf(_("  -Z, --compress=0-9           compression level for compressed formats\n"));
    printf(_("  --lock-wait-timeout=TIMEOUT  fail after waiting TIMEOUT for a table lock\n"));
    printf(_("  -?, --help                   show this help, then exit\n"));

    printf(_("\nOptions controlling the output content:\n"));
    printf(_("  -a, --data-only              dump only the data, not the schema\n"));
    printf(_("  -b, --blobs                  include large objects in dump\n"));
    printf(_("  -c, --clean                  clean (drop) database objects before recreating\n"));
    printf(_("  -C, --create                 include commands to create database in dump\n"));
    printf(_("  -E, --encoding=ENCODING      dump the data in encoding ENCODING\n"));
    printf(_("  -n, --schema=SCHEMA          dump the named schema(s) only\n"));
    printf(_("  -N, --exclude-schema=SCHEMA  do NOT dump the named schema(s)\n"));
    printf(_("  -o, --oids                   include OIDs in dump\n"));
    printf(_("  -O, --no-owner               skip restoration of object ownership in\n"
             "                               plain-text format\n"));
    printf(_("  -s, --schema-only            dump only the schema, no data\n"));
    printf(_("  -S, --superuser=NAME         superuser user name to use in plain-text format\n"));
    printf(_("  -t, --table=TABLE            dump the named table(s) only\n"));
    printf(_("  -T, --exclude-table=TABLE    do NOT dump the named table(s)\n"));
    printf(_("  -x, --no-privileges          do not dump privileges (grant/revoke)\n"));
    printf(_("  --binary-upgrade             for use by upgrade utilities only\n"));
    printf(_("  --column-inserts             dump data as INSERT commands with column names\n"));
    printf(_("  --disable-dollar-quoting     disable dollar quoting, use SQL standard quoting\n"));
    printf(_("  --disable-triggers           disable triggers during data-only restore\n"));
    printf(_("  --exclude-table-data=TABLE   do NOT dump data for the named table(s)\n"));
    printf(_("  --inserts                    dump data as INSERT commands, rather than COPY\n"));
    printf(_("  --no-security-labels         do not dump security label assignments\n"));
    printf(_("  --no-synchronized-snapshots  do not use synchronized snapshots in parallel jobs\n"));
    printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
    printf(_("  --no-unlogged-table-data     do not dump unlogged table data\n"));
    printf(_("  --quote-all-identifiers      quote all identifiers, even if not key words\n"));
    printf(_("  --section=SECTION            dump named section (pre-data, data, or post-data)\n"));
    printf(_("  --serializable-deferrable    wait until the dump can run without anomalies\n"));
    printf(_("  --use-set-session-authorization\n"
             "                               use SET SESSION AUTHORIZATION commands instead of\n"
             "                               ALTER OWNER commands to set ownership\n"));

    printf(_("\nConnection options:\n"));
    printf(_("  -d, --dbname=DBNAME      database to dump\n"));
    printf(_("  -h, --host=HOSTNAME      database server host or socket directory\n"));
    printf(_("  -p, --port=PORT          database server port number\n"));
    printf(_("  -U, --username=NAME      connect as specified database user\n"));
    printf(_("  -w, --no-password        never prompt for password\n"));
    printf(_("  -W, --password           force password prompt (should happen automatically)\n"));
    printf(_("  --role=ROLENAME          do SET ROLE before dump\n"));

    printf(_("\nIf no database name is supplied, then the PGDATABASE environment\n"
             "variable value is used.\n\n"));
    printf(_("Report bugs to <[email protected]>.\n"));
}

int main ( int  argc,
char **  argv 
)

Definition at line 273 of file pg_dump.c.

References _, _restoreOptions::aclsSkip, aclsSkip, addBoundaryDependencies(), archCustom, archDirectory, archNull, binary_upgrade, BuildArchiveDependencies(), buildMatViewRefreshDependencies(), CloseArchive(), column_inserts, _restoreOptions::compression, ConnectDatabase(), CreateArchive(), createBoundaryObjects(), _restoreOptions::createDB, _restoreOptions::dataOnly, dataOnly, disable_dollar_quoting, _restoreOptions::disable_triggers, disable_triggers, _restoreOptions::dropSchema, dump_inserts, dumpDatabase(), dumpDumpableObject(), dumpEncoding(), _restoreOptions::dumpSections, dumpSections, dumpStdStrings(), ExecuteSqlQueryForSingleRow(), exit_horribly(), exit_nicely, expand_schema_name_patterns(), expand_table_name_patterns(), _restoreOptions::filename, filename, findLastBuiltinOid_V70(), findLastBuiltinOid_V71(), format, g_comment_end, g_comment_start, g_last_builtin_oid, g_opaque_type, g_verbose, get_progname(), getBlobs(), GetConnection(), getDependencies(), getDumpableObjects(), getopt_long(), getSchemaData(), getTableData(), getTableDataFKConstraints(), guessConstraintInheritance(), SimpleOidList::head, SimpleStringList::head, help(), i, include_everything, init_parallel_dump_utils(), lockWaitTimeout, Archive::maxRemoteVersion, Archive::minRemoteVersion, NewRestoreOptions(), no_security_labels, no_synchronized_snapshots, no_unlogged_table_data, _restoreOptions::noOwner, _restoreOptions::noTablespace, NULL, numTables, Archive::numWorkers, on_exit_close_archive(), optarg, optind, parseArchiveFormat(), pg_strdup(), PG_TEXTDOMAIN, pghost, pgport, PQclear(), PQdb(), PQgetvalue(), progname, quote_all_identifiers, Archive::remoteVersion, RestoreArchive(), _restoreOptions::schemaOnly, schemaOnly, serializable_deferrable, set_dump_section(), set_pglocale_pgservice(), SetArchiveRestoreOptions(), setup_connection(), setupDumpWorker(), simple_string_list_append(), sortDataAndIndexObjectsBySize(), sortDumpableObjects(), sortDumpableObjectsByTypeName(), sortDumpableObjectsByTypeOid(), _restoreOptions::superuser, _restoreOptions::suppressDumpWarnings, tblinfo, _restoreOptions::use_setsessauth, use_setsessauth, username, username_subquery, Archive::verbose, and write_msg().

{
    int         c;
    const char *filename = NULL;
    const char *format = "p";
    const char *dbname = NULL;
    const char *pghost = NULL;
    const char *pgport = NULL;
    const char *username = NULL;
    const char *dumpencoding = NULL;
    bool        oids = false;
    TableInfo  *tblinfo;
    int         numTables;
    DumpableObject **dobjs;
    int         numObjs;
    DumpableObject *boundaryObjs;
    int         i;
    int         numWorkers = 1;
    enum trivalue prompt_password = TRI_DEFAULT;
    int         compressLevel = -1;
    int         plainText = 0;
    int         outputClean = 0;
    int         outputCreateDB = 0;
    bool        outputBlobs = false;
    int         outputNoOwner = 0;
    char       *outputSuperuser = NULL;
    char       *use_role = NULL;
    int         optindex;
    RestoreOptions *ropt;
    ArchiveFormat archiveFormat = archUnknown;
    ArchiveMode archiveMode;
    Archive    *fout;           /* the script file */

    static int  disable_triggers = 0;
    static int  outputNoTablespaces = 0;
    static int  use_setsessauth = 0;

    static struct option long_options[] = {
        {"data-only", no_argument, NULL, 'a'},
        {"blobs", no_argument, NULL, 'b'},
        {"clean", no_argument, NULL, 'c'},
        {"create", no_argument, NULL, 'C'},
        {"dbname", required_argument, NULL, 'd'},
        {"file", required_argument, NULL, 'f'},
        {"format", required_argument, NULL, 'F'},
        {"host", required_argument, NULL, 'h'},
        {"ignore-version", no_argument, NULL, 'i'},
        {"jobs", 1, NULL, 'j'},
        {"no-reconnect", no_argument, NULL, 'R'},
        {"oids", no_argument, NULL, 'o'},
        {"no-owner", no_argument, NULL, 'O'},
        {"port", required_argument, NULL, 'p'},
        {"schema", required_argument, NULL, 'n'},
        {"exclude-schema", required_argument, NULL, 'N'},
        {"schema-only", no_argument, NULL, 's'},
        {"superuser", required_argument, NULL, 'S'},
        {"table", required_argument, NULL, 't'},
        {"exclude-table", required_argument, NULL, 'T'},
        {"no-password", no_argument, NULL, 'w'},
        {"password", no_argument, NULL, 'W'},
        {"username", required_argument, NULL, 'U'},
        {"verbose", no_argument, NULL, 'v'},
        {"no-privileges", no_argument, NULL, 'x'},
        {"no-acl", no_argument, NULL, 'x'},
        {"compress", required_argument, NULL, 'Z'},
        {"encoding", required_argument, NULL, 'E'},
        {"help", no_argument, NULL, '?'},
        {"version", no_argument, NULL, 'V'},

        /*
         * the following options don't have an equivalent short option letter
         */
        {"attribute-inserts", no_argument, &column_inserts, 1},
        {"binary-upgrade", no_argument, &binary_upgrade, 1},
        {"column-inserts", no_argument, &column_inserts, 1},
        {"disable-dollar-quoting", no_argument, &disable_dollar_quoting, 1},
        {"disable-triggers", no_argument, &disable_triggers, 1},
        {"exclude-table-data", required_argument, NULL, 4},
        {"inserts", no_argument, &dump_inserts, 1},
        {"lock-wait-timeout", required_argument, NULL, 2},
        {"no-tablespaces", no_argument, &outputNoTablespaces, 1},
        {"quote-all-identifiers", no_argument, &quote_all_identifiers, 1},
        {"role", required_argument, NULL, 3},
        {"section", required_argument, NULL, 5},
        {"serializable-deferrable", no_argument, &serializable_deferrable, 1},
        {"use-set-session-authorization", no_argument, &use_setsessauth, 1},
        {"no-security-labels", no_argument, &no_security_labels, 1},
        {"no-synchronized-snapshots", no_argument, &no_synchronized_snapshots, 1},
        {"no-unlogged-table-data", no_argument, &no_unlogged_table_data, 1},

        {NULL, 0, NULL, 0}
    };

    set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_dump"));

    /*
     * Initialize what we need for parallel execution, especially for thread
     * support on Windows.
     */
    init_parallel_dump_utils();

    g_verbose = false;

    strcpy(g_comment_start, "-- ");
    g_comment_end[0] = '\0';
    strcpy(g_opaque_type, "opaque");

    dataOnly = schemaOnly = false;
    dumpSections = DUMP_UNSECTIONED;
    lockWaitTimeout = NULL;

    progname = get_progname(argv[0]);

    /* Set default options based on progname */
    if (strcmp(progname, "pg_backup") == 0)
        format = "c";

    if (argc > 1)
    {
        if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
        {
            help(progname);
            exit_nicely(0);
        }
        if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
        {
            puts("pg_dump (PostgreSQL) " PG_VERSION);
            exit_nicely(0);
        }
    }

    while ((c = getopt_long(argc, argv, "abcCd:E:f:F:h:ij:K:n:N:oOp:RsS:t:T:U:vwWxZ:",
                            long_options, &optindex)) != -1)
    {
        switch (c)
        {
            case 'a':           /* Dump data only */
                dataOnly = true;
                break;

            case 'b':           /* Dump blobs */
                outputBlobs = true;
                break;

            case 'c':           /* clean (i.e., drop) schema prior to create */
                outputClean = 1;
                break;

            case 'C':           /* Create DB */
                outputCreateDB = 1;
                break;

            case 'd':           /* database name */
                dbname = pg_strdup(optarg);
                break;

            case 'E':           /* Dump encoding */
                dumpencoding = pg_strdup(optarg);
                break;

            case 'f':
                filename = pg_strdup(optarg);
                break;

            case 'F':
                format = pg_strdup(optarg);
                break;

            case 'h':           /* server host */
                pghost = pg_strdup(optarg);
                break;

            case 'i':
                /* ignored, deprecated option */
                break;

            case 'j':           /* number of dump jobs */
                numWorkers = atoi(optarg);
                break;

            case 'n':           /* include schema(s) */
                simple_string_list_append(&schema_include_patterns, optarg);
                include_everything = false;
                break;

            case 'N':           /* exclude schema(s) */
                simple_string_list_append(&schema_exclude_patterns, optarg);
                break;

            case 'o':           /* Dump oids */
                oids = true;
                break;

            case 'O':           /* Don't reconnect to match owner */
                outputNoOwner = 1;
                break;

            case 'p':           /* server port */
                pgport = pg_strdup(optarg);
                break;

            case 'R':
                /* no-op, still accepted for backwards compatibility */
                break;

            case 's':           /* dump schema only */
                schemaOnly = true;
                break;

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

            case 't':           /* include table(s) */
                simple_string_list_append(&table_include_patterns, optarg);
                include_everything = false;
                break;

            case 'T':           /* exclude table(s) */
                simple_string_list_append(&table_exclude_patterns, optarg);
                break;

            case 'U':
                username = pg_strdup(optarg);
                break;

            case 'v':           /* verbose */
                g_verbose = true;
                break;

            case 'w':
                prompt_password = TRI_NO;
                break;

            case 'W':
                prompt_password = TRI_YES;
                break;

            case 'x':           /* skip ACL dump */
                aclsSkip = true;
                break;

            case 'Z':           /* Compression Level */
                compressLevel = atoi(optarg);
                break;

            case 0:
                /* This covers the long options. */
                break;

            case 2:             /* lock-wait-timeout */
                lockWaitTimeout = pg_strdup(optarg);
                break;

            case 3:             /* SET ROLE */
                use_role = pg_strdup(optarg);
                break;

            case 4:             /* exclude table(s) data */
                simple_string_list_append(&tabledata_exclude_patterns, optarg);
                break;

            case 5:             /* section */
                set_dump_section(optarg, &dumpSections);
                break;

            default:
                fprintf(stderr, _("Try \"%s --help\" for more information.\n"), progname);
                exit_nicely(1);
        }
    }

    /*
     * Non-option argument specifies database name as long as it wasn't
     * already specified with -d / --dbname
     */
    if (optind < argc && dbname == NULL)
        dbname = argv[optind++];

    /* Complain if any arguments remain */
    if (optind < argc)
    {
        fprintf(stderr, _("%s: too many command-line arguments (first is \"%s\")\n"),
                progname, argv[optind]);
        fprintf(stderr, _("Try \"%s --help\" for more information.\n"),
                progname);
        exit_nicely(1);
    }

    /* --column-inserts implies --inserts */
    if (column_inserts)
        dump_inserts = 1;

    if (dataOnly && schemaOnly)
        exit_horribly(NULL, "options -s/--schema-only and -a/--data-only cannot be used together\n");

    if (dataOnly && outputClean)
        exit_horribly(NULL, "options -c/--clean and -a/--data-only cannot be used together\n");

    if (dump_inserts && oids)
    {
        write_msg(NULL, "options --inserts/--column-inserts and -o/--oids cannot be used together\n");
        write_msg(NULL, "(The INSERT command cannot set OIDs.)\n");
        exit_nicely(1);
    }

    /* Identify archive format to emit */
    archiveFormat = parseArchiveFormat(format, &archiveMode);

    /* archiveFormat specific setup */
    if (archiveFormat == archNull)
        plainText = 1;

    /* Custom and directory formats are compressed by default, others not */
    if (compressLevel == -1)
    {
        if (archiveFormat == archCustom || archiveFormat == archDirectory)
            compressLevel = Z_DEFAULT_COMPRESSION;
        else
            compressLevel = 0;
    }

    /*
     * On Windows we can only have at most MAXIMUM_WAIT_OBJECTS (= 64 usually)
     * parallel jobs because that's the maximum limit for the
     * WaitForMultipleObjects() call.
     */
    if (numWorkers <= 0
#ifdef WIN32
        || numWorkers > MAXIMUM_WAIT_OBJECTS
#endif
        )
        exit_horribly(NULL, "%s: invalid number of parallel jobs\n", progname);

    /* Parallel backup only in the directory archive format so far */
    if (archiveFormat != archDirectory && numWorkers > 1)
        exit_horribly(NULL, "parallel backup only supported by the directory format\n");

    /* Open the output file */
    fout = CreateArchive(filename, archiveFormat, compressLevel, archiveMode,
                         setupDumpWorker);

    /* Register the cleanup hook */
    on_exit_close_archive(fout);

    if (fout == NULL)
        exit_horribly(NULL, "could not open output file \"%s\" for writing\n", filename);

    /* Let the archiver know how noisy to be */
    fout->verbose = g_verbose;

    /*
     * We allow the server to be back to 7.0, and up to any minor release of
     * our own major version.  (See also version check in pg_dumpall.c.)
     */
    fout->minRemoteVersion = 70000;
    fout->maxRemoteVersion = (PG_VERSION_NUM / 100) * 100 + 99;

    fout->numWorkers = numWorkers;

    /*
     * Open the database using the Archiver, so it knows about it. Errors mean
     * death.
     */
    ConnectDatabase(fout, dbname, pghost, pgport, username, prompt_password);
    setup_connection(fout, dumpencoding, use_role);

    /*
     * Disable security label support if server version < v9.1.x (prevents
     * access to nonexistent pg_seclabel catalog)
     */
    if (fout->remoteVersion < 90100)
        no_security_labels = 1;

    /*
     * When running against 9.0 or later, check if we are in recovery mode,
     * which means we are on a hot standby.
     */
    if (fout->remoteVersion >= 90000)
    {
        PGresult   *res = ExecuteSqlQueryForSingleRow(fout, "SELECT pg_catalog.pg_is_in_recovery()");

        if (strcmp(PQgetvalue(res, 0, 0), "t") == 0)
        {
            /*
             * On hot standby slaves, never try to dump unlogged table data,
             * since it will just throw an error.
             */
            no_unlogged_table_data = true;
        }
        PQclear(res);
    }

    /* Select the appropriate subquery to convert user IDs to names */
    if (fout->remoteVersion >= 80100)
        username_subquery = "SELECT rolname FROM pg_catalog.pg_roles WHERE oid =";
    else if (fout->remoteVersion >= 70300)
        username_subquery = "SELECT usename FROM pg_catalog.pg_user WHERE usesysid =";
    else
        username_subquery = "SELECT usename FROM pg_user WHERE usesysid =";

    /* check the version for the synchronized snapshots feature */
    if (numWorkers > 1 && fout->remoteVersion < 90200
        && !no_synchronized_snapshots)
        exit_horribly(NULL,
                      "Synchronized snapshots are not supported by this server version.\n"
                      "Run with --no-synchronized-snapshots instead if you do not need\n"
                      "synchronized snapshots.\n");

    /* Find the last built-in OID, if needed */
    if (fout->remoteVersion < 70300)
    {
        if (fout->remoteVersion >= 70100)
            g_last_builtin_oid = findLastBuiltinOid_V71(fout,
                                                  PQdb(GetConnection(fout)));
        else
            g_last_builtin_oid = findLastBuiltinOid_V70(fout);
        if (g_verbose)
            write_msg(NULL, "last built-in OID is %u\n", g_last_builtin_oid);
    }

    /* Expand schema selection patterns into OID lists */
    if (schema_include_patterns.head != NULL)
    {
        expand_schema_name_patterns(fout, &schema_include_patterns,
                                    &schema_include_oids);
        if (schema_include_oids.head == NULL)
            exit_horribly(NULL, "No matching schemas were found\n");
    }
    expand_schema_name_patterns(fout, &schema_exclude_patterns,
                                &schema_exclude_oids);
    /* non-matching exclusion patterns aren't an error */

    /* Expand table selection patterns into OID lists */
    if (table_include_patterns.head != NULL)
    {
        expand_table_name_patterns(fout, &table_include_patterns,
                                   &table_include_oids);
        if (table_include_oids.head == NULL)
            exit_horribly(NULL, "No matching tables were found\n");
    }
    expand_table_name_patterns(fout, &table_exclude_patterns,
                               &table_exclude_oids);

    expand_table_name_patterns(fout, &tabledata_exclude_patterns,
                               &tabledata_exclude_oids);

    /* non-matching exclusion patterns aren't an error */

    /*
     * Dumping blobs is now default unless we saw an inclusion switch or -s
     * ... but even if we did see one of these, -b turns it back on.
     */
    if (include_everything && !schemaOnly)
        outputBlobs = true;

    /*
     * Now scan the database and create DumpableObject structs for all the
     * objects we intend to dump.
     */
    tblinfo = getSchemaData(fout, &numTables);

    if (fout->remoteVersion < 80400)
        guessConstraintInheritance(tblinfo, numTables);

    if (!schemaOnly)
    {
        getTableData(tblinfo, numTables, oids);
        buildMatViewRefreshDependencies(fout);
        if (dataOnly)
            getTableDataFKConstraints();
    }

    if (outputBlobs)
        getBlobs(fout);

    /*
     * Collect dependency data to assist in ordering the objects.
     */
    getDependencies(fout);

    /* Lastly, create dummy objects to represent the section boundaries */
    boundaryObjs = createBoundaryObjects();

    /* Get pointers to all the known DumpableObjects */
    getDumpableObjects(&dobjs, &numObjs);

    /*
     * Add dummy dependencies to enforce the dump section ordering.
     */
    addBoundaryDependencies(dobjs, numObjs, boundaryObjs);

    /*
     * Sort the objects into a safe dump order (no forward references).
     *
     * In 7.3 or later, we can rely on dependency information to help us
     * determine a safe order, so the initial sort is mostly for cosmetic
     * purposes: we sort by name to ensure that logically identical schemas
     * will dump identically.  Before 7.3 we don't have dependencies and we
     * use OID ordering as an (unreliable) guide to creation order.
     */
    if (fout->remoteVersion >= 70300)
        sortDumpableObjectsByTypeName(dobjs, numObjs);
    else
        sortDumpableObjectsByTypeOid(dobjs, numObjs);

    /* If we do a parallel dump, we want the largest tables to go first */
    if (archiveFormat == archDirectory && numWorkers > 1)
        sortDataAndIndexObjectsBySize(dobjs, numObjs);

    sortDumpableObjects(dobjs, numObjs,
                        boundaryObjs[0].dumpId, boundaryObjs[1].dumpId);

    /*
     * Create archive TOC entries for all the objects to be dumped, in a safe
     * order.
     */

    /* First the special ENCODING and STDSTRINGS entries. */
    dumpEncoding(fout);
    dumpStdStrings(fout);

    /* The database item is always next, unless we don't want it at all */
    if (include_everything && !dataOnly)
        dumpDatabase(fout);

    /* Now the rearrangeable objects. */
    for (i = 0; i < numObjs; i++)
        dumpDumpableObject(fout, dobjs[i]);

    /*
     * Set up options info to ensure we dump what we want.
     */
    ropt = NewRestoreOptions();
    ropt->filename = filename;
    ropt->dropSchema = outputClean;
    ropt->dataOnly = dataOnly;
    ropt->schemaOnly = schemaOnly;
    ropt->dumpSections = dumpSections;
    ropt->aclsSkip = aclsSkip;
    ropt->superuser = outputSuperuser;
    ropt->createDB = outputCreateDB;
    ropt->noOwner = outputNoOwner;
    ropt->noTablespace = outputNoTablespaces;
    ropt->disable_triggers = disable_triggers;
    ropt->use_setsessauth = use_setsessauth;

    if (compressLevel == -1)
        ropt->compression = 0;
    else
        ropt->compression = compressLevel;

    ropt->suppressDumpWarnings = true;  /* We've already shown them */

    SetArchiveRestoreOptions(fout, ropt);

    /*
     * The archive's TOC entries are now marked as to which ones will actually
     * be output, so we can set up their dependency lists properly. This isn't
     * necessary for plain-text output, though.
     */
    if (!plainText)
        BuildArchiveDependencies(fout);

    /*
     * And finally we can do the actual output.
     *
     * Note: for non-plain-text output formats, the output file is written
     * inside CloseArchive().  This is, um, bizarre; but not worth changing
     * right now.
     */
    if (plainText)
        RestoreArchive(fout);

    CloseArchive(fout);

    exit_nicely(0);
}

static void makeTableDataInfo ( TableInfo tbinfo,
bool  oids 
) [static]

Definition at line 1814 of file pg_dump.c.

References addObjectDependency(), AssignDumpId(), _dumpableObject::catId, _tableInfo::dataObj, _tableDataInfo::dobj, _tableInfo::dobj, _dumpableObject::dumpId, _tableDataInfo::filtercond, _dumpableObject::name, no_unlogged_table_data, NULL, _dumpableObject::objType, CatalogId::oid, _tableDataInfo::oids, pg_malloc(), _tableInfo::relkind, RELKIND_FOREIGN_TABLE, RELKIND_MATVIEW, RELKIND_VIEW, _tableInfo::relpersistence, RELPERSISTENCE_UNLOGGED, simple_oid_list_member(), CatalogId::tableoid, and _tableDataInfo::tdtable.

Referenced by getExtensionMembership(), and getTableData().

{
    TableDataInfo *tdinfo;

    /*
     * Nothing to do if we already decided to dump the table.  This will
     * happen for "config" tables.
     */
    if (tbinfo->dataObj != NULL)
        return;

    /* Skip VIEWs (no data to dump) */
    if (tbinfo->relkind == RELKIND_VIEW)
        return;
    /* Skip FOREIGN TABLEs (no data to dump) */
    if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
        return;

    /* Don't dump data in unlogged tables, if so requested */
    if (tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED &&
        no_unlogged_table_data)
        return;

    /* Check that the data is not explicitly excluded */
    if (simple_oid_list_member(&tabledata_exclude_oids,
                               tbinfo->dobj.catId.oid))
        return;

    /* OK, let's dump it */
    tdinfo = (TableDataInfo *) pg_malloc(sizeof(TableDataInfo));

    if (tbinfo->relkind == RELKIND_MATVIEW)
        tdinfo->dobj.objType = DO_REFRESH_MATVIEW;
    else
        tdinfo->dobj.objType = DO_TABLE_DATA;

    /*
     * Note: use tableoid 0 so that this object won't be mistaken for
     * something that pg_depend entries apply to.
     */
    tdinfo->dobj.catId.tableoid = 0;
    tdinfo->dobj.catId.oid = tbinfo->dobj.catId.oid;
    AssignDumpId(&tdinfo->dobj);
    tdinfo->dobj.name = tbinfo->dobj.name;
    tdinfo->dobj.namespace = tbinfo->dobj.namespace;
    tdinfo->tdtable = tbinfo;
    tdinfo->oids = oids;
    tdinfo->filtercond = NULL;  /* might get set later */
    addObjectDependency(&tdinfo->dobj, tbinfo->dobj.dumpId);

    tbinfo->dataObj = tdinfo;
}

static char * myFormatType ( const char *  typname,
int32  typmod 
) [static]

Definition at line 15146 of file pg_dump.c.

References appendPQExpBuffer(), buf, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), fmtId(), pg_strdup(), scale, and VARHDRSZ.

Referenced by dumpTableSchema().

{
    char       *result;
    bool        isarray = false;
    PQExpBuffer buf = createPQExpBuffer();

    /* Handle array types */
    if (typname[0] == '_')
    {
        isarray = true;
        typname++;
    }

    /* Show lengths on bpchar and varchar */
    if (strcmp(typname, "bpchar") == 0)
    {
        int         len = (typmod - VARHDRSZ);

        appendPQExpBuffer(buf, "character");
        if (len > 1)
            appendPQExpBuffer(buf, "(%d)",
                              typmod - VARHDRSZ);
    }
    else if (strcmp(typname, "varchar") == 0)
    {
        appendPQExpBuffer(buf, "character varying");
        if (typmod != -1)
            appendPQExpBuffer(buf, "(%d)",
                              typmod - VARHDRSZ);
    }
    else if (strcmp(typname, "numeric") == 0)
    {
        appendPQExpBuffer(buf, "numeric");
        if (typmod != -1)
        {
            int32       tmp_typmod;
            int         precision;
            int         scale;

            tmp_typmod = typmod - VARHDRSZ;
            precision = (tmp_typmod >> 16) & 0xffff;
            scale = tmp_typmod & 0xffff;
            appendPQExpBuffer(buf, "(%d,%d)",
                              precision, scale);
        }
    }

    /*
     * char is an internal single-byte data type; Let's make sure we force it
     * through with quotes. - thomas 1998-12-13
     */
    else if (strcmp(typname, "char") == 0)
        appendPQExpBuffer(buf, "\"char\"");
    else
        appendPQExpBuffer(buf, "%s", fmtId(typname));

    /* Append array qualifier for array types */
    if (isarray)
        appendPQExpBuffer(buf, "[]");

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

    return result;
}

static ArchiveFormat parseArchiveFormat ( const char *  format,
ArchiveMode mode 
) [static]

Definition at line 1065 of file pg_dump.c.

References exit_horribly(), NULL, and pg_strcasecmp().

Referenced by main().

{
    ArchiveFormat archiveFormat;

    *mode = archModeWrite;

    if (pg_strcasecmp(format, "a") == 0 || pg_strcasecmp(format, "append") == 0)
    {
        /* This is used by pg_dumpall, and is not documented */
        archiveFormat = archNull;
        *mode = archModeAppend;
    }
    else if (pg_strcasecmp(format, "c") == 0)
        archiveFormat = archCustom;
    else if (pg_strcasecmp(format, "custom") == 0)
        archiveFormat = archCustom;
    else if (pg_strcasecmp(format, "d") == 0)
        archiveFormat = archDirectory;
    else if (pg_strcasecmp(format, "directory") == 0)
        archiveFormat = archDirectory;
    else if (pg_strcasecmp(format, "p") == 0)
        archiveFormat = archNull;
    else if (pg_strcasecmp(format, "plain") == 0)
        archiveFormat = archNull;
    else if (pg_strcasecmp(format, "t") == 0)
        archiveFormat = archTar;
    else if (pg_strcasecmp(format, "tar") == 0)
        archiveFormat = archTar;
    else
        exit_horribly(NULL, "invalid output format \"%s\" specified\n", format);
    return archiveFormat;
}

static void refreshMatViewData ( Archive fout,
TableDataInfo tdinfo 
) [static]

Definition at line 1756 of file pg_dump.c.

References appendPQExpBuffer(), ArchiveEntry(), _dumpableObject::catId, createPQExpBuffer(), PQExpBufferData::data, _dumpableObject::dependencies, destroyPQExpBuffer(), _tableDataInfo::dobj, _tableInfo::dobj, _dumpableObject::dumpId, fmtId(), _tableInfo::isscannable, _dumpableObject::name, _dumpableObject::nDeps, NULL, _tableInfo::rolname, SECTION_POST_DATA, and _tableDataInfo::tdtable.

Referenced by dumpDumpableObject().

{
    TableInfo  *tbinfo = tdinfo->tdtable;
    PQExpBuffer q;

    /* If the materialized view is not flagged as scannable, skip this. */
    if (!tbinfo->isscannable)
        return;

    q = createPQExpBuffer();

    appendPQExpBuffer(q, "REFRESH MATERIALIZED VIEW %s;\n",
                      fmtId(tbinfo->dobj.name));

    ArchiveEntry(fout,
                 tdinfo->dobj.catId,    /* catalog ID */
                 tdinfo->dobj.dumpId,   /* dump ID */
                 tbinfo->dobj.name,     /* Name */
                 tbinfo->dobj.namespace->dobj.name,     /* Namespace */
                 NULL,          /* Tablespace */
                 tbinfo->rolname,       /* Owner */
                 false,         /* with oids */
                 "MATERIALIZED VIEW DATA",      /* Desc */
                 SECTION_POST_DATA,     /* Section */
                 q->data,       /* Create */
                 "",            /* Del */
                 NULL,          /* Copy */
                 tdinfo->dobj.dependencies,     /* Deps */
                 tdinfo->dobj.nDeps,    /* # Deps */
                 NULL,          /* Dumper */
                 NULL);         /* Dumper Arg */

    destroyPQExpBuffer(q);
}

static void selectDumpableDefaultACL ( DefaultACLInfo dinfo  )  [static]

Definition at line 1318 of file pg_dump.c.

References _defaultACLInfo::dobj, _dumpableObject::dump, and include_everything.

Referenced by getDefaultACLs().

{
    if (dinfo->dobj.namespace)
        dinfo->dobj.dump = dinfo->dobj.namespace->dobj.dump;
    else
        dinfo->dobj.dump = include_everything;
}

static void selectDumpableExtension ( ExtensionInfo extinfo  )  [static]
static void selectDumpableNamespace ( NamespaceInfo nsinfo  )  [static]

Definition at line 1201 of file pg_dump.c.

References _dumpableObject::catId, _namespaceInfo::dobj, _dumpableObject::dump, SimpleOidList::head, _dumpableObject::name, NULL, CatalogId::oid, and simple_oid_list_member().

Referenced by getNamespaces().

{
    /*
     * If specific tables are being dumped, do not dump any complete
     * namespaces. If specific namespaces are being dumped, dump just those
     * namespaces. Otherwise, dump all non-system namespaces.
     */
    if (table_include_oids.head != NULL)
        nsinfo->dobj.dump = false;
    else if (schema_include_oids.head != NULL)
        nsinfo->dobj.dump = simple_oid_list_member(&schema_include_oids,
                                                   nsinfo->dobj.catId.oid);
    else if (strncmp(nsinfo->dobj.name, "pg_", 3) == 0 ||
             strcmp(nsinfo->dobj.name, "information_schema") == 0)
        nsinfo->dobj.dump = false;
    else
        nsinfo->dobj.dump = true;

    /*
     * In any case, a namespace can be excluded by an exclusion switch
     */
    if (nsinfo->dobj.dump &&
        simple_oid_list_member(&schema_exclude_oids,
                               nsinfo->dobj.catId.oid))
        nsinfo->dobj.dump = false;
}

static void selectDumpableObject ( DumpableObject dobj  )  [static]

Definition at line 1352 of file pg_dump.c.

References _dumpableObject::dump.

Referenced by getAggregates(), getCollations(), getConversions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getOpclasses(), getOperators(), getOpfamilies(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), and getTSTemplates().

{
    /*
     * Default policy is to dump if parent namespace is dumpable, or always
     * for non-namespace-associated items.
     */
    if (dobj->namespace)
        dobj->dump = dobj->namespace->dobj.dump;
    else
        dobj->dump = true;
}

static void selectDumpableTable ( TableInfo tbinfo  )  [static]

Definition at line 1233 of file pg_dump.c.

References _dumpableObject::catId, _tableInfo::dobj, _dumpableObject::dump, SimpleOidList::head, NULL, CatalogId::oid, and simple_oid_list_member().

Referenced by getTables().

{
    /*
     * If specific tables are being dumped, dump just those tables; else, dump
     * according to the parent namespace's dump flag.
     */
    if (table_include_oids.head != NULL)
        tbinfo->dobj.dump = simple_oid_list_member(&table_include_oids,
                                                   tbinfo->dobj.catId.oid);
    else
        tbinfo->dobj.dump = tbinfo->dobj.namespace->dobj.dump;

    /*
     * In any case, a table can be excluded by an exclusion switch
     */
    if (tbinfo->dobj.dump &&
        simple_oid_list_member(&table_exclude_oids,
                               tbinfo->dobj.catId.oid))
        tbinfo->dobj.dump = false;
}

static void selectDumpableType ( TypeInfo tyinfo  )  [static]

Definition at line 1268 of file pg_dump.c.

References _tableInfo::dobj, _dumpableObject::dump, findTableByOid(), NULL, OidIsValid, and RELKIND_COMPOSITE_TYPE.

Referenced by getTypes().

{
    /* skip complex types, except for standalone composite types */
    if (OidIsValid(tyinfo->typrelid) &&
        tyinfo->typrelkind != RELKIND_COMPOSITE_TYPE)
    {
        TableInfo  *tytable = findTableByOid(tyinfo->typrelid);

        tyinfo->dobj.objType = DO_DUMMY_TYPE;
        if (tytable != NULL)
            tyinfo->dobj.dump = tytable->dobj.dump;
        else
            tyinfo->dobj.dump = false;
        return;
    }

    /* skip auto-generated array types */
    if (tyinfo->isArray)
    {
        tyinfo->dobj.objType = DO_DUMMY_TYPE;

        /*
         * Fall through to set the dump flag; we assume that the subsequent
         * rules will do the same thing as they would for the array's base
         * type.  (We cannot reliably look up the base type here, since
         * getTypes may not have processed it yet.)
         */
    }

    /* dump only types in dumpable namespaces */
    if (!tyinfo->dobj.namespace->dobj.dump)
        tyinfo->dobj.dump = false;

    /* skip undefined placeholder types */
    else if (!tyinfo->isDefined)
        tyinfo->dobj.dump = false;

    else
        tyinfo->dobj.dump = true;
}

static void selectSourceSchema ( Archive fout,
const char *  schemaName 
) [static]

Definition at line 15056 of file pg_dump.c.

References appendPQExpBuffer(), Assert, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), ExecuteSqlStatement(), fmtId(), NULL, and Archive::remoteVersion.

Referenced by buildMatViewRefreshDependencies(), dumpAgg(), dumpBaseType(), dumpBlobs(), dumpCast(), dumpCollation(), dumpCompositeType(), dumpConversion(), dumpDatabase(), dumpDomain(), dumpEnumType(), dumpForeignServer(), dumpFunc(), dumpOpclass(), dumpOpfamily(), dumpOpr(), dumpRangeType(), dumpRule(), dumpSequence(), dumpSequenceData(), dumpTableData_copy(), dumpTableData_insert(), dumpTableSchema(), dumpTSConfig(), dumpTSDictionary(), dumpTSParser(), dumpTSTemplate(), dumpUserMappings(), getAggregates(), getBlobs(), getCasts(), getCollations(), getConstraints(), getConversions(), getDefaultACLs(), getDependencies(), getDomainConstraints(), getEventTriggers(), getExtensionMembership(), getExtensions(), getForeignDataWrappers(), getForeignServers(), getFuncs(), getIndexes(), getInherits(), getNamespaces(), getOpclasses(), getOperators(), getOpfamilies(), getProcLangs(), getRules(), getTableAttrs(), getTables(), getTriggers(), getTSConfigurations(), getTSDictionaries(), getTSParsers(), getTSTemplates(), and getTypes().

{
    PQExpBuffer query;

    /* This is checked by the callers already */
    Assert(schemaName != NULL && *schemaName != '\0');

    /* Not relevant if fetching from pre-7.3 DB */
    if (fout->remoteVersion < 70300)
        return;

    query = createPQExpBuffer();
    appendPQExpBuffer(query, "SET search_path = %s",
                      fmtId(schemaName));
    if (strcmp(schemaName, "pg_catalog") != 0)
        appendPQExpBuffer(query, ", pg_catalog");

    ExecuteSqlStatement(fout, query->data);

    destroyPQExpBuffer(query);
}

static void setup_connection ( Archive AH,
const char *  dumpencoding,
char *  use_role 
) [static]

Definition at line 919 of file pg_dump.c.

References appendPQExpBuffer(), appendStringLiteralConn(), conn, createPQExpBuffer(), PQExpBufferData::data, destroyPQExpBuffer(), Archive::encoding, ExecuteSqlStatement(), exit_horribly(), fmtId(), get_synchronized_snapshot(), GetConnection(), no_synchronized_snapshots, NULL, Archive::numWorkers, PQclientEncoding(), PQparameterStatus(), PQsetClientEncoding(), quote_all_identifiers, Archive::remoteVersion, serializable_deferrable, Archive::std_strings, Archive::sync_snapshot_id, and Archive::use_role.

Referenced by main(), and setupDumpWorker().

{
    PGconn     *conn = GetConnection(AH);
    const char *std_strings;

    /*
     * Set the client encoding if requested. If dumpencoding == NULL then
     * either it hasn't been requested or we're a cloned connection and then
     * this has already been set in CloneArchive according to the original
     * connection encoding.
     */
    if (dumpencoding)
    {
        if (PQsetClientEncoding(conn, dumpencoding) < 0)
            exit_horribly(NULL, "invalid client encoding \"%s\" specified\n",
                          dumpencoding);
    }

    /*
     * Get the active encoding and the standard_conforming_strings setting, so
     * we know how to escape strings.
     */
    AH->encoding = PQclientEncoding(conn);

    std_strings = PQparameterStatus(conn, "standard_conforming_strings");
    AH->std_strings = (std_strings && strcmp(std_strings, "on") == 0);

    /* Set the role if requested */
    if (!use_role && AH->use_role)
        use_role = AH->use_role;

    /* Set the role if requested */
    if (use_role && AH->remoteVersion >= 80100)
    {
        PQExpBuffer query = createPQExpBuffer();

        appendPQExpBuffer(query, "SET ROLE %s", fmtId(use_role));
        ExecuteSqlStatement(AH, query->data);
        destroyPQExpBuffer(query);

        /* save this for later use on parallel connections */
        if (!AH->use_role)
            AH->use_role = strdup(use_role);
    }

    /* Set the datestyle to ISO to ensure the dump's portability */
    ExecuteSqlStatement(AH, "SET DATESTYLE = ISO");

    /* Likewise, avoid using sql_standard intervalstyle */
    if (AH->remoteVersion >= 80400)
        ExecuteSqlStatement(AH, "SET INTERVALSTYLE = POSTGRES");

    /*
     * If supported, set extra_float_digits so that we can dump float data
     * exactly (given correctly implemented float I/O code, anyway)
     */
    if (AH->remoteVersion >= 90000)
        ExecuteSqlStatement(AH, "SET extra_float_digits TO 3");
    else if (AH->remoteVersion >= 70400)
        ExecuteSqlStatement(AH, "SET extra_float_digits TO 2");

    /*
     * If synchronized scanning is supported, disable it, to prevent
     * unpredictable changes in row ordering across a dump and reload.
     */
    if (AH->remoteVersion >= 80300)
        ExecuteSqlStatement(AH, "SET synchronize_seqscans TO off");

    /*
     * Disable timeouts if supported.
     */
    if (AH->remoteVersion >= 70300)
        ExecuteSqlStatement(AH, "SET statement_timeout = 0");
    if (AH->remoteVersion >= 90300)
        ExecuteSqlStatement(AH, "SET lock_timeout = 0");

    /*
     * Quote all identifiers, if requested.
     */
    if (quote_all_identifiers && AH->remoteVersion >= 90100)
        ExecuteSqlStatement(AH, "SET quote_all_identifiers = true");

    /*
     * Start transaction-snapshot mode transaction to dump consistent data.
     */
    ExecuteSqlStatement(AH, "BEGIN");
    if (AH->remoteVersion >= 90100)
    {
        if (serializable_deferrable)
            ExecuteSqlStatement(AH,
                                "SET TRANSACTION ISOLATION LEVEL "
                                "SERIALIZABLE, READ ONLY, DEFERRABLE");
        else
            ExecuteSqlStatement(AH,
                                "SET TRANSACTION ISOLATION LEVEL "
                                "REPEATABLE READ, READ ONLY");
    }
    else if (AH->remoteVersion >= 70400)
    {
        /* note: comma was not accepted in SET TRANSACTION before 8.0 */
        ExecuteSqlStatement(AH,
                            "SET TRANSACTION ISOLATION LEVEL "
                            "SERIALIZABLE READ ONLY");
    }
    else
        ExecuteSqlStatement(AH,
                            "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE");



    if (AH->numWorkers > 1 && AH->remoteVersion >= 90200 && !no_synchronized_snapshots)
    {
        if (AH->sync_snapshot_id)
        {
            PQExpBuffer query = createPQExpBuffer();

            appendPQExpBuffer(query, "SET TRANSACTION SNAPSHOT ");
            appendStringLiteralConn(query, AH->sync_snapshot_id, conn);
            destroyPQExpBuffer(query);
        }
        else
            AH->sync_snapshot_id = get_synchronized_snapshot(AH);
    }
}

static void setupDumpWorker ( Archive AHX,
RestoreOptions ropt 
) [static]

Definition at line 1045 of file pg_dump.c.

References NULL, and setup_connection().

Referenced by main().

static bool shouldDumpProcLangs ( void   )  [static]

Definition at line 9179 of file pg_dump.c.

References dataOnly, and include_everything.

Referenced by dumpProcLang().

{
    if (!include_everything)
        return false;
    /* And they're schema not data */
    if (dataOnly)
        return false;
    return true;
}

bool shouldPrintColumn ( TableInfo tbinfo,
int  colno 
)

Definition at line 6680 of file pg_dump.c.

References _tableInfo::attisdropped, _tableInfo::attislocal, and binary_upgrade.

Referenced by dumpTableSchema(), flagInhAttrs(), and getTableAttrs().

{
    if (binary_upgrade)
        return true;
    return (tbinfo->attislocal[colno] && !tbinfo->attisdropped[colno]);
}


Variable Documentation

Definition at line 96 of file pg_dump.c.

Referenced by dumpACL(), dumpDefaultACL(), and main().

int binary_upgrade = 0 [static]
int column_inserts = 0 [static]

Definition at line 138 of file pg_dump.c.

Referenced by dumpTableData_insert(), and main().

int disable_dollar_quoting = 0 [static]

Definition at line 136 of file pg_dump.c.

Referenced by dumpFunc(), and main().

int dump_inserts = 0 [static]

Definition at line 137 of file pg_dump.c.

Referenced by dumpTableData(), and main().

Definition at line 95 of file pg_dump.c.

Referenced by main().

char g_comment_end[10]

Definition at line 130 of file pg_dump.c.

Referenced by main().

char g_comment_start[10]

Definition at line 129 of file pg_dump.c.

Referenced by main().

Definition at line 103 of file pg_dump.c.

Referenced by findNamespace(), getAggregates(), getFuncs(), and main().

char g_opaque_type[10]

Definition at line 126 of file pg_dump.c.

Referenced by getFormattedTypeName(), and main().

bool include_everything = true [static]
const char* lockWaitTimeout

Definition at line 97 of file pg_dump.c.

Referenced by getTables(), and main().

const CatalogId nilCatalogId = {0, 0} [static]

Definition at line 132 of file pg_dump.c.

int no_security_labels = 0 [static]

Definition at line 139 of file pg_dump.c.

Referenced by dumpDatabase(), dumpSecLabel(), dumpTableSecLabel(), and main().

int no_synchronized_snapshots = 0 [static]

Definition at line 140 of file pg_dump.c.

Referenced by main(), and setup_connection().

int no_unlogged_table_data = 0 [static]

Definition at line 141 of file pg_dump.c.

Referenced by main(), and makeTableDataInfo().

char* optarg

Definition at line 51 of file getopt.c.

int opterr

Definition at line 48 of file getopt.c.

int optind

Definition at line 49 of file getopt.c.

SimpleOidList schema_exclude_oids = {NULL, NULL} [static]

Definition at line 114 of file pg_dump.c.

SimpleStringList schema_exclude_patterns = {NULL, NULL} [static]

Definition at line 113 of file pg_dump.c.

SimpleOidList schema_include_oids = {NULL, NULL} [static]

Definition at line 112 of file pg_dump.c.

SimpleStringList schema_include_patterns = {NULL, NULL} [static]

Definition at line 111 of file pg_dump.c.

Definition at line 93 of file pg_dump.c.

Referenced by dumpComment(), dumpSecLabel(), and main().

int serializable_deferrable = 0 [static]

Definition at line 142 of file pg_dump.c.

Referenced by main(), and setup_connection().

SimpleOidList table_exclude_oids = {NULL, NULL} [static]

Definition at line 119 of file pg_dump.c.

SimpleStringList table_exclude_patterns = {NULL, NULL} [static]

Definition at line 118 of file pg_dump.c.

SimpleOidList table_include_oids = {NULL, NULL} [static]

Definition at line 117 of file pg_dump.c.

SimpleStringList table_include_patterns = {NULL, NULL} [static]

Definition at line 116 of file pg_dump.c.

SimpleOidList tabledata_exclude_oids = {NULL, NULL} [static]

Definition at line 121 of file pg_dump.c.

Definition at line 120 of file pg_dump.c.

const char* username_subquery [static]