LCOV - code coverage report
Current view: top level - src/bin/pg_dump - pg_dump.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 7256 8037 90.3 %
Date: 2025-04-24 13:15:39 Functions: 184 188 97.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * pg_dump.c
       4             :  *    pg_dump is a utility for dumping out a postgres database
       5             :  *    into a script file.
       6             :  *
       7             :  * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  *  pg_dump will read the system catalogs in a database and dump out a
      11             :  *  script that reproduces the schema in terms of SQL that is understood
      12             :  *  by PostgreSQL
      13             :  *
      14             :  *  Note that pg_dump runs in a transaction-snapshot mode transaction,
      15             :  *  so it sees a consistent snapshot of the database including system
      16             :  *  catalogs. However, it relies in part on various specialized backend
      17             :  *  functions like pg_get_indexdef(), and those things tend to look at
      18             :  *  the currently committed state.  So it is possible to get 'cache
      19             :  *  lookup failed' error if someone performs DDL changes while a dump is
      20             :  *  happening. The window for this sort of thing is from the acquisition
      21             :  *  of the transaction snapshot to getSchemaData() (when pg_dump acquires
      22             :  *  AccessShareLock on every table it intends to dump). It isn't very large,
      23             :  *  but it can happen.
      24             :  *
      25             :  *  http://archives.postgresql.org/pgsql-bugs/2010-02/msg00187.php
      26             :  *
      27             :  * IDENTIFICATION
      28             :  *    src/bin/pg_dump/pg_dump.c
      29             :  *
      30             :  *-------------------------------------------------------------------------
      31             :  */
      32             : #include "postgres_fe.h"
      33             : 
      34             : #include <unistd.h>
      35             : #include <ctype.h>
      36             : #include <limits.h>
      37             : #ifdef HAVE_TERMIOS_H
      38             : #include <termios.h>
      39             : #endif
      40             : 
      41             : #include "access/attnum.h"
      42             : #include "access/sysattr.h"
      43             : #include "access/transam.h"
      44             : #include "catalog/pg_aggregate_d.h"
      45             : #include "catalog/pg_am_d.h"
      46             : #include "catalog/pg_attribute_d.h"
      47             : #include "catalog/pg_authid_d.h"
      48             : #include "catalog/pg_cast_d.h"
      49             : #include "catalog/pg_class_d.h"
      50             : #include "catalog/pg_default_acl_d.h"
      51             : #include "catalog/pg_largeobject_d.h"
      52             : #include "catalog/pg_proc_d.h"
      53             : #include "catalog/pg_publication_d.h"
      54             : #include "catalog/pg_subscription_d.h"
      55             : #include "catalog/pg_type_d.h"
      56             : #include "common/connect.h"
      57             : #include "common/int.h"
      58             : #include "common/relpath.h"
      59             : #include "common/shortest_dec.h"
      60             : #include "compress_io.h"
      61             : #include "dumputils.h"
      62             : #include "fe_utils/option_utils.h"
      63             : #include "fe_utils/string_utils.h"
      64             : #include "filter.h"
      65             : #include "getopt_long.h"
      66             : #include "libpq/libpq-fs.h"
      67             : #include "parallel.h"
      68             : #include "pg_backup_db.h"
      69             : #include "pg_backup_utils.h"
      70             : #include "pg_dump.h"
      71             : #include "storage/block.h"
      72             : 
      73             : typedef struct
      74             : {
      75             :     Oid         roleoid;        /* role's OID */
      76             :     const char *rolename;       /* role's name */
      77             : } RoleNameItem;
      78             : 
      79             : typedef struct
      80             : {
      81             :     const char *descr;          /* comment for an object */
      82             :     Oid         classoid;       /* object class (catalog OID) */
      83             :     Oid         objoid;         /* object OID */
      84             :     int         objsubid;       /* subobject (table column #) */
      85             : } CommentItem;
      86             : 
      87             : typedef struct
      88             : {
      89             :     const char *provider;       /* label provider of this security label */
      90             :     const char *label;          /* security label for an object */
      91             :     Oid         classoid;       /* object class (catalog OID) */
      92             :     Oid         objoid;         /* object OID */
      93             :     int         objsubid;       /* subobject (table column #) */
      94             : } SecLabelItem;
      95             : 
      96             : typedef struct
      97             : {
      98             :     Oid         oid;            /* object OID */
      99             :     char        relkind;        /* object kind */
     100             :     RelFileNumber relfilenumber;    /* object filenode */
     101             :     Oid         toast_oid;      /* toast table OID */
     102             :     RelFileNumber toast_relfilenumber;  /* toast table filenode */
     103             :     Oid         toast_index_oid;    /* toast table index OID */
     104             :     RelFileNumber toast_index_relfilenumber;    /* toast table index filenode */
     105             : } BinaryUpgradeClassOidItem;
     106             : 
     107             : /* sequence types */
     108             : typedef enum SeqType
     109             : {
     110             :     SEQTYPE_SMALLINT,
     111             :     SEQTYPE_INTEGER,
     112             :     SEQTYPE_BIGINT,
     113             : } SeqType;
     114             : 
     115             : static const char *const SeqTypeNames[] =
     116             : {
     117             :     [SEQTYPE_SMALLINT] = "smallint",
     118             :     [SEQTYPE_INTEGER] = "integer",
     119             :     [SEQTYPE_BIGINT] = "bigint",
     120             : };
     121             : 
     122             : StaticAssertDecl(lengthof(SeqTypeNames) == (SEQTYPE_BIGINT + 1),
     123             :                  "array length mismatch");
     124             : 
     125             : typedef struct
     126             : {
     127             :     Oid         oid;            /* sequence OID */
     128             :     SeqType     seqtype;        /* data type of sequence */
     129             :     bool        cycled;         /* whether sequence cycles */
     130             :     int64       minv;           /* minimum value */
     131             :     int64       maxv;           /* maximum value */
     132             :     int64       startv;         /* start value */
     133             :     int64       incby;          /* increment value */
     134             :     int64       cache;          /* cache size */
     135             :     int64       last_value;     /* last value of sequence */
     136             :     bool        is_called;      /* whether nextval advances before returning */
     137             : } SequenceItem;
     138             : 
     139             : typedef enum OidOptions
     140             : {
     141             :     zeroIsError = 1,
     142             :     zeroAsStar = 2,
     143             :     zeroAsNone = 4,
     144             : } OidOptions;
     145             : 
     146             : /* global decls */
     147             : static bool dosync = true;      /* Issue fsync() to make dump durable on disk. */
     148             : 
     149             : static Oid  g_last_builtin_oid; /* value of the last builtin oid */
     150             : 
     151             : /* The specified names/patterns should to match at least one entity */
     152             : static int  strict_names = 0;
     153             : 
     154             : static pg_compress_algorithm compression_algorithm = PG_COMPRESSION_NONE;
     155             : 
     156             : /*
     157             :  * Object inclusion/exclusion lists
     158             :  *
     159             :  * The string lists record the patterns given by command-line switches,
     160             :  * which we then convert to lists of OIDs of matching objects.
     161             :  */
     162             : static SimpleStringList schema_include_patterns = {NULL, NULL};
     163             : static SimpleOidList schema_include_oids = {NULL, NULL};
     164             : static SimpleStringList schema_exclude_patterns = {NULL, NULL};
     165             : static SimpleOidList schema_exclude_oids = {NULL, NULL};
     166             : 
     167             : static SimpleStringList table_include_patterns = {NULL, NULL};
     168             : static SimpleStringList table_include_patterns_and_children = {NULL, NULL};
     169             : static SimpleOidList table_include_oids = {NULL, NULL};
     170             : static SimpleStringList table_exclude_patterns = {NULL, NULL};
     171             : static SimpleStringList table_exclude_patterns_and_children = {NULL, NULL};
     172             : static SimpleOidList table_exclude_oids = {NULL, NULL};
     173             : static SimpleStringList tabledata_exclude_patterns = {NULL, NULL};
     174             : static SimpleStringList tabledata_exclude_patterns_and_children = {NULL, NULL};
     175             : static SimpleOidList tabledata_exclude_oids = {NULL, NULL};
     176             : 
     177             : static SimpleStringList foreign_servers_include_patterns = {NULL, NULL};
     178             : static SimpleOidList foreign_servers_include_oids = {NULL, NULL};
     179             : 
     180             : static SimpleStringList extension_include_patterns = {NULL, NULL};
     181             : static SimpleOidList extension_include_oids = {NULL, NULL};
     182             : 
     183             : static SimpleStringList extension_exclude_patterns = {NULL, NULL};
     184             : static SimpleOidList extension_exclude_oids = {NULL, NULL};
     185             : 
     186             : static const CatalogId nilCatalogId = {0, 0};
     187             : 
     188             : /* override for standard extra_float_digits setting */
     189             : static bool have_extra_float_digits = false;
     190             : static int  extra_float_digits;
     191             : 
     192             : /* sorted table of role names */
     193             : static RoleNameItem *rolenames = NULL;
     194             : static int  nrolenames = 0;
     195             : 
     196             : /* sorted table of comments */
     197             : static CommentItem *comments = NULL;
     198             : static int  ncomments = 0;
     199             : 
     200             : /* sorted table of security labels */
     201             : static SecLabelItem *seclabels = NULL;
     202             : static int  nseclabels = 0;
     203             : 
     204             : /* sorted table of pg_class information for binary upgrade */
     205             : static BinaryUpgradeClassOidItem *binaryUpgradeClassOids = NULL;
     206             : static int  nbinaryUpgradeClassOids = 0;
     207             : 
     208             : /* sorted table of sequences */
     209             : static SequenceItem *sequences = NULL;
     210             : static int  nsequences = 0;
     211             : 
     212             : /* Maximum number of relations to fetch in a fetchAttributeStats() call. */
     213             : #define MAX_ATTR_STATS_RELS 64
     214             : 
     215             : /*
     216             :  * The default number of rows per INSERT when
     217             :  * --inserts is specified without --rows-per-insert
     218             :  */
     219             : #define DUMP_DEFAULT_ROWS_PER_INSERT 1
     220             : 
     221             : /*
     222             :  * Maximum number of large objects to group into a single ArchiveEntry.
     223             :  * At some point we might want to make this user-controllable, but for now
     224             :  * a hard-wired setting will suffice.
     225             :  */
     226             : #define MAX_BLOBS_PER_ARCHIVE_ENTRY 1000
     227             : 
     228             : /*
     229             :  * Macro for producing quoted, schema-qualified name of a dumpable object.
     230             :  */
     231             : #define fmtQualifiedDumpable(obj) \
     232             :     fmtQualifiedId((obj)->dobj.namespace->dobj.name, \
     233             :                    (obj)->dobj.name)
     234             : 
     235             : static void help(const char *progname);
     236             : static void setup_connection(Archive *AH,
     237             :                              const char *dumpencoding, const char *dumpsnapshot,
     238             :                              char *use_role);
     239             : static ArchiveFormat parseArchiveFormat(const char *format, ArchiveMode *mode);
     240             : static void expand_schema_name_patterns(Archive *fout,
     241             :                                         SimpleStringList *patterns,
     242             :                                         SimpleOidList *oids,
     243             :                                         bool strict_names);
     244             : static void expand_extension_name_patterns(Archive *fout,
     245             :                                            SimpleStringList *patterns,
     246             :                                            SimpleOidList *oids,
     247             :                                            bool strict_names);
     248             : static void expand_foreign_server_name_patterns(Archive *fout,
     249             :                                                 SimpleStringList *patterns,
     250             :                                                 SimpleOidList *oids);
     251             : static void expand_table_name_patterns(Archive *fout,
     252             :                                        SimpleStringList *patterns,
     253             :                                        SimpleOidList *oids,
     254             :                                        bool strict_names,
     255             :                                        bool with_child_tables);
     256             : static void prohibit_crossdb_refs(PGconn *conn, const char *dbname,
     257             :                                   const char *pattern);
     258             : 
     259             : static NamespaceInfo *findNamespace(Oid nsoid);
     260             : static void dumpTableData(Archive *fout, const TableDataInfo *tdinfo);
     261             : static void refreshMatViewData(Archive *fout, const TableDataInfo *tdinfo);
     262             : static const char *getRoleName(const char *roleoid_str);
     263             : static void collectRoleNames(Archive *fout);
     264             : static void getAdditionalACLs(Archive *fout);
     265             : static void dumpCommentExtended(Archive *fout, const char *type,
     266             :                                 const char *name, const char *namespace,
     267             :                                 const char *owner, CatalogId catalogId,
     268             :                                 int subid, DumpId dumpId,
     269             :                                 const char *initdb_comment);
     270             : static inline void dumpComment(Archive *fout, const char *type,
     271             :                                const char *name, const char *namespace,
     272             :                                const char *owner, CatalogId catalogId,
     273             :                                int subid, DumpId dumpId);
     274             : static int  findComments(Oid classoid, Oid objoid, CommentItem **items);
     275             : static void collectComments(Archive *fout);
     276             : static void dumpSecLabel(Archive *fout, const char *type, const char *name,
     277             :                          const char *namespace, const char *owner,
     278             :                          CatalogId catalogId, int subid, DumpId dumpId);
     279             : static int  findSecLabels(Oid classoid, Oid objoid, SecLabelItem **items);
     280             : static void collectSecLabels(Archive *fout);
     281             : static void dumpDumpableObject(Archive *fout, DumpableObject *dobj);
     282             : static void dumpNamespace(Archive *fout, const NamespaceInfo *nspinfo);
     283             : static void dumpExtension(Archive *fout, const ExtensionInfo *extinfo);
     284             : static void dumpType(Archive *fout, const TypeInfo *tyinfo);
     285             : static void dumpBaseType(Archive *fout, const TypeInfo *tyinfo);
     286             : static void dumpEnumType(Archive *fout, const TypeInfo *tyinfo);
     287             : static void dumpRangeType(Archive *fout, const TypeInfo *tyinfo);
     288             : static void dumpUndefinedType(Archive *fout, const TypeInfo *tyinfo);
     289             : static void dumpDomain(Archive *fout, const TypeInfo *tyinfo);
     290             : static void dumpCompositeType(Archive *fout, const TypeInfo *tyinfo);
     291             : static void dumpCompositeTypeColComments(Archive *fout, const TypeInfo *tyinfo,
     292             :                                          PGresult *res);
     293             : static void dumpShellType(Archive *fout, const ShellTypeInfo *stinfo);
     294             : static void dumpProcLang(Archive *fout, const ProcLangInfo *plang);
     295             : static void dumpFunc(Archive *fout, const FuncInfo *finfo);
     296             : static void dumpCast(Archive *fout, const CastInfo *cast);
     297             : static void dumpTransform(Archive *fout, const TransformInfo *transform);
     298             : static void dumpOpr(Archive *fout, const OprInfo *oprinfo);
     299             : static void dumpAccessMethod(Archive *fout, const AccessMethodInfo *aminfo);
     300             : static void dumpOpclass(Archive *fout, const OpclassInfo *opcinfo);
     301             : static void dumpOpfamily(Archive *fout, const OpfamilyInfo *opfinfo);
     302             : static void dumpCollation(Archive *fout, const CollInfo *collinfo);
     303             : static void dumpConversion(Archive *fout, const ConvInfo *convinfo);
     304             : static void dumpRule(Archive *fout, const RuleInfo *rinfo);
     305             : static void dumpAgg(Archive *fout, const AggInfo *agginfo);
     306             : static void dumpTrigger(Archive *fout, const TriggerInfo *tginfo);
     307             : static void dumpEventTrigger(Archive *fout, const EventTriggerInfo *evtinfo);
     308             : static void dumpTable(Archive *fout, const TableInfo *tbinfo);
     309             : static void dumpTableSchema(Archive *fout, const TableInfo *tbinfo);
     310             : static void dumpTableAttach(Archive *fout, const TableAttachInfo *attachinfo);
     311             : static void dumpAttrDef(Archive *fout, const AttrDefInfo *adinfo);
     312             : static void collectSequences(Archive *fout);
     313             : static void dumpSequence(Archive *fout, const TableInfo *tbinfo);
     314             : static void dumpSequenceData(Archive *fout, const TableDataInfo *tdinfo);
     315             : static void dumpIndex(Archive *fout, const IndxInfo *indxinfo);
     316             : static void dumpIndexAttach(Archive *fout, const IndexAttachInfo *attachinfo);
     317             : static void dumpStatisticsExt(Archive *fout, const StatsExtInfo *statsextinfo);
     318             : static void dumpConstraint(Archive *fout, const ConstraintInfo *coninfo);
     319             : static void dumpTableConstraintComment(Archive *fout, const ConstraintInfo *coninfo);
     320             : static void dumpTSParser(Archive *fout, const TSParserInfo *prsinfo);
     321             : static void dumpTSDictionary(Archive *fout, const TSDictInfo *dictinfo);
     322             : static void dumpTSTemplate(Archive *fout, const TSTemplateInfo *tmplinfo);
     323             : static void dumpTSConfig(Archive *fout, const TSConfigInfo *cfginfo);
     324             : static void dumpForeignDataWrapper(Archive *fout, const FdwInfo *fdwinfo);
     325             : static void dumpForeignServer(Archive *fout, const ForeignServerInfo *srvinfo);
     326             : static void dumpUserMappings(Archive *fout,
     327             :                              const char *servername, const char *namespace,
     328             :                              const char *owner, CatalogId catalogId, DumpId dumpId);
     329             : static void dumpDefaultACL(Archive *fout, const DefaultACLInfo *daclinfo);
     330             : 
     331             : static DumpId dumpACL(Archive *fout, DumpId objDumpId, DumpId altDumpId,
     332             :                       const char *type, const char *name, const char *subname,
     333             :                       const char *nspname, const char *tag, const char *owner,
     334             :                       const DumpableAcl *dacl);
     335             : 
     336             : static void getDependencies(Archive *fout);
     337             : static void BuildArchiveDependencies(Archive *fout);
     338             : static void findDumpableDependencies(ArchiveHandle *AH, const DumpableObject *dobj,
     339             :                                      DumpId **dependencies, int *nDeps, int *allocDeps);
     340             : 
     341             : static DumpableObject *createBoundaryObjects(void);
     342             : static void addBoundaryDependencies(DumpableObject **dobjs, int numObjs,
     343             :                                     DumpableObject *boundaryObjs);
     344             : 
     345             : static void addConstrChildIdxDeps(DumpableObject *dobj, const IndxInfo *refidx);
     346             : static void getDomainConstraints(Archive *fout, TypeInfo *tyinfo);
     347             : static void getTableData(DumpOptions *dopt, TableInfo *tblinfo, int numTables, char relkind);
     348             : static void makeTableDataInfo(DumpOptions *dopt, TableInfo *tbinfo);
     349             : static void buildMatViewRefreshDependencies(Archive *fout);
     350             : static void getTableDataFKConstraints(void);
     351             : static void determineNotNullFlags(Archive *fout, PGresult *res, int r,
     352             :                                   TableInfo *tbinfo, int j,
     353             :                                   int i_notnull_name, int i_notnull_invalidoid,
     354             :                                   int i_notnull_noinherit,
     355             :                                   int i_notnull_islocal,
     356             :                                   PQExpBuffer *invalidnotnulloids);
     357             : static char *format_function_arguments(const FuncInfo *finfo, const char *funcargs,
     358             :                                        bool is_agg);
     359             : static char *format_function_signature(Archive *fout,
     360             :                                        const FuncInfo *finfo, bool honor_quotes);
     361             : static char *convertRegProcReference(const char *proc);
     362             : static char *getFormattedOperatorName(const char *oproid);
     363             : static char *convertTSFunction(Archive *fout, Oid funcOid);
     364             : static const char *getFormattedTypeName(Archive *fout, Oid oid, OidOptions opts);
     365             : static void getLOs(Archive *fout);
     366             : static void dumpLO(Archive *fout, const LoInfo *loinfo);
     367             : static int  dumpLOs(Archive *fout, const void *arg);
     368             : static void dumpPolicy(Archive *fout, const PolicyInfo *polinfo);
     369             : static void dumpPublication(Archive *fout, const PublicationInfo *pubinfo);
     370             : static void dumpPublicationTable(Archive *fout, const PublicationRelInfo *pubrinfo);
     371             : static void dumpSubscription(Archive *fout, const SubscriptionInfo *subinfo);
     372             : static void dumpSubscriptionTable(Archive *fout, const SubRelInfo *subrinfo);
     373             : static void dumpDatabase(Archive *fout);
     374             : static void dumpDatabaseConfig(Archive *AH, PQExpBuffer outbuf,
     375             :                                const char *dbname, Oid dboid);
     376             : static void dumpEncoding(Archive *AH);
     377             : static void dumpStdStrings(Archive *AH);
     378             : static void dumpSearchPath(Archive *AH);
     379             : static void binary_upgrade_set_type_oids_by_type_oid(Archive *fout,
     380             :                                                      PQExpBuffer upgrade_buffer,
     381             :                                                      Oid pg_type_oid,
     382             :                                                      bool force_array_type,
     383             :                                                      bool include_multirange_type);
     384             : static void binary_upgrade_set_type_oids_by_rel(Archive *fout,
     385             :                                                 PQExpBuffer upgrade_buffer,
     386             :                                                 const TableInfo *tbinfo);
     387             : static void collectBinaryUpgradeClassOids(Archive *fout);
     388             : static void binary_upgrade_set_pg_class_oids(Archive *fout,
     389             :                                              PQExpBuffer upgrade_buffer,
     390             :                                              Oid pg_class_oid);
     391             : static void binary_upgrade_extension_member(PQExpBuffer upgrade_buffer,
     392             :                                             const DumpableObject *dobj,
     393             :                                             const char *objtype,
     394             :                                             const char *objname,
     395             :                                             const char *objnamespace);
     396             : static const char *getAttrName(int attrnum, const TableInfo *tblInfo);
     397             : static const char *fmtCopyColumnList(const TableInfo *ti, PQExpBuffer buffer);
     398             : static bool nonemptyReloptions(const char *reloptions);
     399             : static void appendReloptionsArrayAH(PQExpBuffer buffer, const char *reloptions,
     400             :                                     const char *prefix, Archive *fout);
     401             : static char *get_synchronized_snapshot(Archive *fout);
     402             : static void set_restrict_relation_kind(Archive *AH, const char *value);
     403             : static void setupDumpWorker(Archive *AH);
     404             : static TableInfo *getRootTableInfo(const TableInfo *tbinfo);
     405             : static bool forcePartitionRootLoad(const TableInfo *tbinfo);
     406             : static void read_dump_filters(const char *filename, DumpOptions *dopt);
     407             : 
     408             : 
     409             : int
     410         696 : main(int argc, char **argv)
     411             : {
     412             :     int         c;
     413         696 :     const char *filename = NULL;
     414         696 :     const char *format = "p";
     415             :     TableInfo  *tblinfo;
     416             :     int         numTables;
     417             :     DumpableObject **dobjs;
     418             :     int         numObjs;
     419             :     DumpableObject *boundaryObjs;
     420             :     int         i;
     421             :     int         optindex;
     422             :     RestoreOptions *ropt;
     423             :     Archive    *fout;           /* the script file */
     424         696 :     bool        g_verbose = false;
     425         696 :     const char *dumpencoding = NULL;
     426         696 :     const char *dumpsnapshot = NULL;
     427         696 :     char       *use_role = NULL;
     428         696 :     int         numWorkers = 1;
     429         696 :     int         plainText = 0;
     430         696 :     ArchiveFormat archiveFormat = archUnknown;
     431             :     ArchiveMode archiveMode;
     432         696 :     pg_compress_specification compression_spec = {0};
     433         696 :     char       *compression_detail = NULL;
     434         696 :     char       *compression_algorithm_str = "none";
     435         696 :     char       *error_detail = NULL;
     436         696 :     bool        user_compression_defined = false;
     437         696 :     DataDirSyncMethod sync_method = DATA_DIR_SYNC_METHOD_FSYNC;
     438         696 :     bool        data_only = false;
     439         696 :     bool        schema_only = false;
     440         696 :     bool        statistics_only = false;
     441         696 :     bool        with_data = false;
     442         696 :     bool        with_schema = false;
     443         696 :     bool        with_statistics = false;
     444         696 :     bool        no_data = false;
     445         696 :     bool        no_schema = false;
     446         696 :     bool        no_statistics = false;
     447             : 
     448             :     static DumpOptions dopt;
     449             : 
     450             :     static struct option long_options[] = {
     451             :         {"data-only", no_argument, NULL, 'a'},
     452             :         {"blobs", no_argument, NULL, 'b'},
     453             :         {"large-objects", no_argument, NULL, 'b'},
     454             :         {"no-blobs", no_argument, NULL, 'B'},
     455             :         {"no-large-objects", no_argument, NULL, 'B'},
     456             :         {"clean", no_argument, NULL, 'c'},
     457             :         {"create", no_argument, NULL, 'C'},
     458             :         {"dbname", required_argument, NULL, 'd'},
     459             :         {"extension", required_argument, NULL, 'e'},
     460             :         {"file", required_argument, NULL, 'f'},
     461             :         {"format", required_argument, NULL, 'F'},
     462             :         {"host", required_argument, NULL, 'h'},
     463             :         {"jobs", 1, NULL, 'j'},
     464             :         {"no-reconnect", no_argument, NULL, 'R'},
     465             :         {"no-owner", no_argument, NULL, 'O'},
     466             :         {"port", required_argument, NULL, 'p'},
     467             :         {"schema", required_argument, NULL, 'n'},
     468             :         {"exclude-schema", required_argument, NULL, 'N'},
     469             :         {"schema-only", no_argument, NULL, 's'},
     470             :         {"superuser", required_argument, NULL, 'S'},
     471             :         {"table", required_argument, NULL, 't'},
     472             :         {"exclude-table", required_argument, NULL, 'T'},
     473             :         {"no-password", no_argument, NULL, 'w'},
     474             :         {"password", no_argument, NULL, 'W'},
     475             :         {"username", required_argument, NULL, 'U'},
     476             :         {"verbose", no_argument, NULL, 'v'},
     477             :         {"no-privileges", no_argument, NULL, 'x'},
     478             :         {"no-acl", no_argument, NULL, 'x'},
     479             :         {"compress", required_argument, NULL, 'Z'},
     480             :         {"encoding", required_argument, NULL, 'E'},
     481             :         {"help", no_argument, NULL, '?'},
     482             :         {"version", no_argument, NULL, 'V'},
     483             : 
     484             :         /*
     485             :          * the following options don't have an equivalent short option letter
     486             :          */
     487             :         {"attribute-inserts", no_argument, &dopt.column_inserts, 1},
     488             :         {"binary-upgrade", no_argument, &dopt.binary_upgrade, 1},
     489             :         {"column-inserts", no_argument, &dopt.column_inserts, 1},
     490             :         {"disable-dollar-quoting", no_argument, &dopt.disable_dollar_quoting, 1},
     491             :         {"disable-triggers", no_argument, &dopt.disable_triggers, 1},
     492             :         {"enable-row-security", no_argument, &dopt.enable_row_security, 1},
     493             :         {"exclude-table-data", required_argument, NULL, 4},
     494             :         {"extra-float-digits", required_argument, NULL, 8},
     495             :         {"if-exists", no_argument, &dopt.if_exists, 1},
     496             :         {"inserts", no_argument, NULL, 9},
     497             :         {"lock-wait-timeout", required_argument, NULL, 2},
     498             :         {"no-table-access-method", no_argument, &dopt.outputNoTableAm, 1},
     499             :         {"no-tablespaces", no_argument, &dopt.outputNoTablespaces, 1},
     500             :         {"quote-all-identifiers", no_argument, &quote_all_identifiers, 1},
     501             :         {"load-via-partition-root", no_argument, &dopt.load_via_partition_root, 1},
     502             :         {"role", required_argument, NULL, 3},
     503             :         {"section", required_argument, NULL, 5},
     504             :         {"serializable-deferrable", no_argument, &dopt.serializable_deferrable, 1},
     505             :         {"snapshot", required_argument, NULL, 6},
     506             :         {"statistics-only", no_argument, NULL, 18},
     507             :         {"strict-names", no_argument, &strict_names, 1},
     508             :         {"use-set-session-authorization", no_argument, &dopt.use_setsessauth, 1},
     509             :         {"no-comments", no_argument, &dopt.no_comments, 1},
     510             :         {"no-data", no_argument, NULL, 19},
     511             :         {"no-policies", no_argument, &dopt.no_policies, 1},
     512             :         {"no-publications", no_argument, &dopt.no_publications, 1},
     513             :         {"no-schema", no_argument, NULL, 20},
     514             :         {"no-security-labels", no_argument, &dopt.no_security_labels, 1},
     515             :         {"no-statistics", no_argument, NULL, 21},
     516             :         {"no-subscriptions", no_argument, &dopt.no_subscriptions, 1},
     517             :         {"no-toast-compression", no_argument, &dopt.no_toast_compression, 1},
     518             :         {"no-unlogged-table-data", no_argument, &dopt.no_unlogged_table_data, 1},
     519             :         {"no-sync", no_argument, NULL, 7},
     520             :         {"with-data", no_argument, NULL, 22},
     521             :         {"with-schema", no_argument, NULL, 23},
     522             :         {"with-statistics", no_argument, NULL, 24},
     523             :         {"on-conflict-do-nothing", no_argument, &dopt.do_nothing, 1},
     524             :         {"rows-per-insert", required_argument, NULL, 10},
     525             :         {"include-foreign-data", required_argument, NULL, 11},
     526             :         {"table-and-children", required_argument, NULL, 12},
     527             :         {"exclude-table-and-children", required_argument, NULL, 13},
     528             :         {"exclude-table-data-and-children", required_argument, NULL, 14},
     529             :         {"sync-method", required_argument, NULL, 15},
     530             :         {"filter", required_argument, NULL, 16},
     531             :         {"exclude-extension", required_argument, NULL, 17},
     532             :         {"sequence-data", no_argument, &dopt.sequence_data, 1},
     533             : 
     534             :         {NULL, 0, NULL, 0}
     535             :     };
     536             : 
     537         696 :     pg_logging_init(argv[0]);
     538         696 :     pg_logging_set_level(PG_LOG_WARNING);
     539         696 :     set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_dump"));
     540             : 
     541             :     /*
     542             :      * Initialize what we need for parallel execution, especially for thread
     543             :      * support on Windows.
     544             :      */
     545         696 :     init_parallel_dump_utils();
     546             : 
     547         696 :     progname = get_progname(argv[0]);
     548             : 
     549         696 :     if (argc > 1)
     550             :     {
     551         696 :         if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
     552             :         {
     553           2 :             help(progname);
     554           2 :             exit_nicely(0);
     555             :         }
     556         694 :         if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
     557             :         {
     558         138 :             puts("pg_dump (PostgreSQL) " PG_VERSION);
     559         138 :             exit_nicely(0);
     560             :         }
     561             :     }
     562             : 
     563         556 :     InitDumpOptions(&dopt);
     564             : 
     565        2624 :     while ((c = getopt_long(argc, argv, "abBcCd:e:E:f:F:h:j:n:N:Op:RsS:t:T:U:vwWxXZ:",
     566             :                             long_options, &optindex)) != -1)
     567             :     {
     568        2084 :         switch (c)
     569             :         {
     570          18 :             case 'a':           /* Dump data only */
     571          18 :                 data_only = true;
     572          18 :                 break;
     573             : 
     574           2 :             case 'b':           /* Dump LOs */
     575           2 :                 dopt.outputLOs = true;
     576           2 :                 break;
     577             : 
     578           4 :             case 'B':           /* Don't dump LOs */
     579           4 :                 dopt.dontOutputLOs = true;
     580           4 :                 break;
     581             : 
     582          12 :             case 'c':           /* clean (i.e., drop) schema prior to create */
     583          12 :                 dopt.outputClean = 1;
     584          12 :                 break;
     585             : 
     586         140 :             case 'C':           /* Create DB */
     587         140 :                 dopt.outputCreateDB = 1;
     588         140 :                 break;
     589             : 
     590          16 :             case 'd':           /* database name */
     591          16 :                 dopt.cparams.dbname = pg_strdup(optarg);
     592          16 :                 break;
     593             : 
     594           8 :             case 'e':           /* include extension(s) */
     595           8 :                 simple_string_list_append(&extension_include_patterns, optarg);
     596           8 :                 dopt.include_everything = false;
     597           8 :                 break;
     598             : 
     599           4 :             case 'E':           /* Dump encoding */
     600           4 :                 dumpencoding = pg_strdup(optarg);
     601           4 :                 break;
     602             : 
     603         466 :             case 'f':
     604         466 :                 filename = pg_strdup(optarg);
     605         466 :                 break;
     606             : 
     607         314 :             case 'F':
     608         314 :                 format = pg_strdup(optarg);
     609         314 :                 break;
     610             : 
     611          58 :             case 'h':           /* server host */
     612          58 :                 dopt.cparams.pghost = pg_strdup(optarg);
     613          58 :                 break;
     614             : 
     615          24 :             case 'j':           /* number of dump jobs */
     616          24 :                 if (!option_parse_int(optarg, "-j/--jobs", 1,
     617             :                                       PG_MAX_JOBS,
     618             :                                       &numWorkers))
     619           2 :                     exit_nicely(1);
     620          22 :                 break;
     621             : 
     622          34 :             case 'n':           /* include schema(s) */
     623          34 :                 simple_string_list_append(&schema_include_patterns, optarg);
     624          34 :                 dopt.include_everything = false;
     625          34 :                 break;
     626             : 
     627           2 :             case 'N':           /* exclude schema(s) */
     628           2 :                 simple_string_list_append(&schema_exclude_patterns, optarg);
     629           2 :                 break;
     630             : 
     631           4 :             case 'O':           /* Don't reconnect to match owner */
     632           4 :                 dopt.outputNoOwner = 1;
     633           4 :                 break;
     634             : 
     635         134 :             case 'p':           /* server port */
     636         134 :                 dopt.cparams.pgport = pg_strdup(optarg);
     637         134 :                 break;
     638             : 
     639           4 :             case 'R':
     640             :                 /* no-op, still accepted for backwards compatibility */
     641           4 :                 break;
     642             : 
     643          14 :             case 's':           /* dump schema only */
     644          14 :                 schema_only = true;
     645          14 :                 break;
     646             : 
     647           2 :             case 'S':           /* Username for superuser in plain text output */
     648           2 :                 dopt.outputSuperuser = pg_strdup(optarg);
     649           2 :                 break;
     650             : 
     651          16 :             case 't':           /* include table(s) */
     652          16 :                 simple_string_list_append(&table_include_patterns, optarg);
     653          16 :                 dopt.include_everything = false;
     654          16 :                 break;
     655             : 
     656           8 :             case 'T':           /* exclude table(s) */
     657           8 :                 simple_string_list_append(&table_exclude_patterns, optarg);
     658           8 :                 break;
     659             : 
     660          62 :             case 'U':
     661          62 :                 dopt.cparams.username = pg_strdup(optarg);
     662          62 :                 break;
     663             : 
     664          12 :             case 'v':           /* verbose */
     665          12 :                 g_verbose = true;
     666          12 :                 pg_logging_increase_verbosity();
     667          12 :                 break;
     668             : 
     669           2 :             case 'w':
     670           2 :                 dopt.cparams.promptPassword = TRI_NO;
     671           2 :                 break;
     672             : 
     673           0 :             case 'W':
     674           0 :                 dopt.cparams.promptPassword = TRI_YES;
     675           0 :                 break;
     676             : 
     677           4 :             case 'x':           /* skip ACL dump */
     678           4 :                 dopt.aclsSkip = true;
     679           4 :                 break;
     680             : 
     681          24 :             case 'Z':           /* Compression */
     682          24 :                 parse_compress_options(optarg, &compression_algorithm_str,
     683             :                                        &compression_detail);
     684          24 :                 user_compression_defined = true;
     685          24 :                 break;
     686             : 
     687         226 :             case 0:
     688             :                 /* This covers the long options. */
     689         226 :                 break;
     690             : 
     691           4 :             case 2:             /* lock-wait-timeout */
     692           4 :                 dopt.lockWaitTimeout = pg_strdup(optarg);
     693           4 :                 break;
     694             : 
     695           6 :             case 3:             /* SET ROLE */
     696           6 :                 use_role = pg_strdup(optarg);
     697           6 :                 break;
     698             : 
     699           2 :             case 4:             /* exclude table(s) data */
     700           2 :                 simple_string_list_append(&tabledata_exclude_patterns, optarg);
     701           2 :                 break;
     702             : 
     703          12 :             case 5:             /* section */
     704          12 :                 set_dump_section(optarg, &dopt.dumpSections);
     705          12 :                 break;
     706             : 
     707           0 :             case 6:             /* snapshot */
     708           0 :                 dumpsnapshot = pg_strdup(optarg);
     709           0 :                 break;
     710             : 
     711         274 :             case 7:             /* no-sync */
     712         274 :                 dosync = false;
     713         274 :                 break;
     714             : 
     715           2 :             case 8:
     716           2 :                 have_extra_float_digits = true;
     717           2 :                 if (!option_parse_int(optarg, "--extra-float-digits", -15, 3,
     718             :                                       &extra_float_digits))
     719           2 :                     exit_nicely(1);
     720           0 :                 break;
     721             : 
     722           4 :             case 9:             /* inserts */
     723             : 
     724             :                 /*
     725             :                  * dump_inserts also stores --rows-per-insert, careful not to
     726             :                  * overwrite that.
     727             :                  */
     728           4 :                 if (dopt.dump_inserts == 0)
     729           4 :                     dopt.dump_inserts = DUMP_DEFAULT_ROWS_PER_INSERT;
     730           4 :                 break;
     731             : 
     732           4 :             case 10:            /* rows per insert */
     733           4 :                 if (!option_parse_int(optarg, "--rows-per-insert", 1, INT_MAX,
     734             :                                       &dopt.dump_inserts))
     735           2 :                     exit_nicely(1);
     736           2 :                 break;
     737             : 
     738           8 :             case 11:            /* include foreign data */
     739           8 :                 simple_string_list_append(&foreign_servers_include_patterns,
     740             :                                           optarg);
     741           8 :                 break;
     742             : 
     743           2 :             case 12:            /* include table(s) and their children */
     744           2 :                 simple_string_list_append(&table_include_patterns_and_children,
     745             :                                           optarg);
     746           2 :                 dopt.include_everything = false;
     747           2 :                 break;
     748             : 
     749           2 :             case 13:            /* exclude table(s) and their children */
     750           2 :                 simple_string_list_append(&table_exclude_patterns_and_children,
     751             :                                           optarg);
     752           2 :                 break;
     753             : 
     754           2 :             case 14:            /* exclude data of table(s) and children */
     755           2 :                 simple_string_list_append(&tabledata_exclude_patterns_and_children,
     756             :                                           optarg);
     757           2 :                 break;
     758             : 
     759           0 :             case 15:
     760           0 :                 if (!parse_sync_method(optarg, &sync_method))
     761           0 :                     exit_nicely(1);
     762           0 :                 break;
     763             : 
     764          52 :             case 16:            /* read object filters from file */
     765          52 :                 read_dump_filters(optarg, &dopt);
     766          44 :                 break;
     767             : 
     768           2 :             case 17:            /* exclude extension(s) */
     769           2 :                 simple_string_list_append(&extension_exclude_patterns,
     770             :                                           optarg);
     771           2 :                 break;
     772             : 
     773           8 :             case 18:
     774           8 :                 statistics_only = true;
     775           8 :                 break;
     776             : 
     777          62 :             case 19:
     778          62 :                 no_data = true;
     779          62 :                 break;
     780             : 
     781           4 :             case 20:
     782           4 :                 no_schema = true;
     783           4 :                 break;
     784             : 
     785          16 :             case 21:
     786          16 :                 no_statistics = true;
     787          16 :                 break;
     788             : 
     789           0 :             case 22:
     790           0 :                 with_data = true;
     791           0 :                 break;
     792             : 
     793           0 :             case 23:
     794           0 :                 with_schema = true;
     795           0 :                 break;
     796             : 
     797           2 :             case 24:
     798           2 :                 with_statistics = true;
     799           2 :                 break;
     800             : 
     801           2 :             default:
     802             :                 /* getopt_long already emitted a complaint */
     803           2 :                 pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     804           2 :                 exit_nicely(1);
     805             :         }
     806             :     }
     807             : 
     808             :     /*
     809             :      * Non-option argument specifies database name as long as it wasn't
     810             :      * already specified with -d / --dbname
     811             :      */
     812         540 :     if (optind < argc && dopt.cparams.dbname == NULL)
     813         464 :         dopt.cparams.dbname = argv[optind++];
     814             : 
     815             :     /* Complain if any arguments remain */
     816         540 :     if (optind < argc)
     817             :     {
     818           2 :         pg_log_error("too many command-line arguments (first is \"%s\")",
     819             :                      argv[optind]);
     820           2 :         pg_log_error_hint("Try \"%s --help\" for more information.", progname);
     821           2 :         exit_nicely(1);
     822             :     }
     823             : 
     824             :     /* --column-inserts implies --inserts */
     825         538 :     if (dopt.column_inserts && dopt.dump_inserts == 0)
     826           2 :         dopt.dump_inserts = DUMP_DEFAULT_ROWS_PER_INSERT;
     827             : 
     828             :     /* reject conflicting "-only" options */
     829         538 :     if (data_only && schema_only)
     830           2 :         pg_fatal("options -s/--schema-only and -a/--data-only cannot be used together");
     831         536 :     if (schema_only && statistics_only)
     832           2 :         pg_fatal("options -s/--schema-only and --statistics-only cannot be used together");
     833         534 :     if (data_only && statistics_only)
     834           2 :         pg_fatal("options -a/--data-only and --statistics-only cannot be used together");
     835             : 
     836             :     /* reject conflicting "-only" and "no-" options */
     837         532 :     if (data_only && no_data)
     838           0 :         pg_fatal("options -a/--data-only and --no-data cannot be used together");
     839         532 :     if (schema_only && no_schema)
     840           0 :         pg_fatal("options -s/--schema-only and --no-schema cannot be used together");
     841         532 :     if (statistics_only && no_statistics)
     842           2 :         pg_fatal("options --statistics-only and --no-statistics cannot be used together");
     843             : 
     844             :     /* reject conflicting "with-" and "no-" options */
     845         530 :     if (with_data && no_data)
     846           0 :         pg_fatal("options --with-data and --no-data cannot be used together");
     847         530 :     if (with_schema && no_schema)
     848           0 :         pg_fatal("options --with-schema and --no-schema cannot be used together");
     849         530 :     if (with_statistics && no_statistics)
     850           0 :         pg_fatal("options --with-statistics and --no-statistics cannot be used together");
     851             : 
     852         530 :     if (schema_only && foreign_servers_include_patterns.head != NULL)
     853           2 :         pg_fatal("options -s/--schema-only and --include-foreign-data cannot be used together");
     854             : 
     855         528 :     if (numWorkers > 1 && foreign_servers_include_patterns.head != NULL)
     856           2 :         pg_fatal("option --include-foreign-data is not supported with parallel backup");
     857             : 
     858         526 :     if (data_only && dopt.outputClean)
     859           2 :         pg_fatal("options -c/--clean and -a/--data-only cannot be used together");
     860             : 
     861         524 :     if (dopt.if_exists && !dopt.outputClean)
     862           2 :         pg_fatal("option --if-exists requires option -c/--clean");
     863             : 
     864             :     /*
     865             :      * Set derivative flags. An "-only" option may be overridden by an
     866             :      * explicit "with-" option; e.g. "--schema-only --with-statistics" will
     867             :      * include schema and statistics. Other ambiguous or nonsensical
     868             :      * combinations, e.g. "--schema-only --no-schema", will have already
     869             :      * caused an error in one of the checks above.
     870             :      */
     871         522 :     dopt.dumpData = ((dopt.dumpData && !schema_only && !statistics_only) ||
     872        1044 :                      (data_only || with_data)) && !no_data;
     873         522 :     dopt.dumpSchema = ((dopt.dumpSchema && !data_only && !statistics_only) ||
     874        1044 :                        (schema_only || with_schema)) && !no_schema;
     875         522 :     dopt.dumpStatistics = ((dopt.dumpStatistics && !schema_only && !data_only) ||
     876        1044 :                            (statistics_only || with_statistics)) && !no_statistics;
     877             : 
     878             : 
     879             :     /*
     880             :      * --inserts are already implied above if --column-inserts or
     881             :      * --rows-per-insert were specified.
     882             :      */
     883         522 :     if (dopt.do_nothing && dopt.dump_inserts == 0)
     884           2 :         pg_fatal("option --on-conflict-do-nothing requires option --inserts, --rows-per-insert, or --column-inserts");
     885             : 
     886             :     /* Identify archive format to emit */
     887         520 :     archiveFormat = parseArchiveFormat(format, &archiveMode);
     888             : 
     889             :     /* archiveFormat specific setup */
     890         518 :     if (archiveFormat == archNull)
     891         310 :         plainText = 1;
     892             : 
     893             :     /*
     894             :      * Custom and directory formats are compressed by default with gzip when
     895             :      * available, not the others.  If gzip is not available, no compression is
     896             :      * done by default.
     897             :      */
     898         518 :     if ((archiveFormat == archCustom || archiveFormat == archDirectory) &&
     899         186 :         !user_compression_defined)
     900             :     {
     901             : #ifdef HAVE_LIBZ
     902         176 :         compression_algorithm_str = "gzip";
     903             : #else
     904             :         compression_algorithm_str = "none";
     905             : #endif
     906             :     }
     907             : 
     908             :     /*
     909             :      * Compression options
     910             :      */
     911         518 :     if (!parse_compress_algorithm(compression_algorithm_str,
     912             :                                   &compression_algorithm))
     913           2 :         pg_fatal("unrecognized compression algorithm: \"%s\"",
     914             :                  compression_algorithm_str);
     915             : 
     916         516 :     parse_compress_specification(compression_algorithm, compression_detail,
     917             :                                  &compression_spec);
     918         516 :     error_detail = validate_compress_specification(&compression_spec);
     919         516 :     if (error_detail != NULL)
     920           6 :         pg_fatal("invalid compression specification: %s",
     921             :                  error_detail);
     922             : 
     923         510 :     error_detail = supports_compression(compression_spec);
     924         510 :     if (error_detail != NULL)
     925           0 :         pg_fatal("%s", error_detail);
     926             : 
     927             :     /*
     928             :      * Disable support for zstd workers for now - these are based on
     929             :      * threading, and it's unclear how it interacts with parallel dumps on
     930             :      * platforms where that relies on threads too (e.g. Windows).
     931             :      */
     932         510 :     if (compression_spec.options & PG_COMPRESSION_OPTION_WORKERS)
     933           0 :         pg_log_warning("compression option \"%s\" is not currently supported by pg_dump",
     934             :                        "workers");
     935             : 
     936             :     /*
     937             :      * If emitting an archive format, we always want to emit a DATABASE item,
     938             :      * in case --create is specified at pg_restore time.
     939             :      */
     940         510 :     if (!plainText)
     941         208 :         dopt.outputCreateDB = 1;
     942             : 
     943             :     /* Parallel backup only in the directory archive format so far */
     944         510 :     if (archiveFormat != archDirectory && numWorkers > 1)
     945           2 :         pg_fatal("parallel backup only supported by the directory format");
     946             : 
     947             :     /* Open the output file */
     948         508 :     fout = CreateArchive(filename, archiveFormat, compression_spec,
     949             :                          dosync, archiveMode, setupDumpWorker, sync_method);
     950             : 
     951             :     /* Make dump options accessible right away */
     952         506 :     SetArchiveOptions(fout, &dopt, NULL);
     953             : 
     954             :     /* Register the cleanup hook */
     955         506 :     on_exit_close_archive(fout);
     956             : 
     957             :     /* Let the archiver know how noisy to be */
     958         506 :     fout->verbose = g_verbose;
     959             : 
     960             : 
     961             :     /*
     962             :      * We allow the server to be back to 9.2, and up to any minor release of
     963             :      * our own major version.  (See also version check in pg_dumpall.c.)
     964             :      */
     965         506 :     fout->minRemoteVersion = 90200;
     966         506 :     fout->maxRemoteVersion = (PG_VERSION_NUM / 100) * 100 + 99;
     967             : 
     968         506 :     fout->numWorkers = numWorkers;
     969             : 
     970             :     /*
     971             :      * Open the database using the Archiver, so it knows about it. Errors mean
     972             :      * death.
     973             :      */
     974         506 :     ConnectDatabaseAhx(fout, &dopt.cparams, false);
     975         502 :     setup_connection(fout, dumpencoding, dumpsnapshot, use_role);
     976             : 
     977             :     /*
     978             :      * On hot standbys, never try to dump unlogged table data, since it will
     979             :      * just throw an error.
     980             :      */
     981         502 :     if (fout->isStandby)
     982           8 :         dopt.no_unlogged_table_data = true;
     983             : 
     984             :     /*
     985             :      * Find the last built-in OID, if needed (prior to 8.1)
     986             :      *
     987             :      * With 8.1 and above, we can just use FirstNormalObjectId - 1.
     988             :      */
     989         502 :     g_last_builtin_oid = FirstNormalObjectId - 1;
     990             : 
     991         502 :     pg_log_info("last built-in OID is %u", g_last_builtin_oid);
     992             : 
     993             :     /* Expand schema selection patterns into OID lists */
     994         502 :     if (schema_include_patterns.head != NULL)
     995             :     {
     996          36 :         expand_schema_name_patterns(fout, &schema_include_patterns,
     997             :                                     &schema_include_oids,
     998             :                                     strict_names);
     999          24 :         if (schema_include_oids.head == NULL)
    1000           2 :             pg_fatal("no matching schemas were found");
    1001             :     }
    1002         488 :     expand_schema_name_patterns(fout, &schema_exclude_patterns,
    1003             :                                 &schema_exclude_oids,
    1004             :                                 false);
    1005             :     /* non-matching exclusion patterns aren't an error */
    1006             : 
    1007             :     /* Expand table selection patterns into OID lists */
    1008         488 :     expand_table_name_patterns(fout, &table_include_patterns,
    1009             :                                &table_include_oids,
    1010             :                                strict_names, false);
    1011         478 :     expand_table_name_patterns(fout, &table_include_patterns_and_children,
    1012             :                                &table_include_oids,
    1013             :                                strict_names, true);
    1014         478 :     if ((table_include_patterns.head != NULL ||
    1015         456 :          table_include_patterns_and_children.head != NULL) &&
    1016          26 :         table_include_oids.head == NULL)
    1017           4 :         pg_fatal("no matching tables were found");
    1018             : 
    1019         474 :     expand_table_name_patterns(fout, &table_exclude_patterns,
    1020             :                                &table_exclude_oids,
    1021             :                                false, false);
    1022         474 :     expand_table_name_patterns(fout, &table_exclude_patterns_and_children,
    1023             :                                &table_exclude_oids,
    1024             :                                false, true);
    1025             : 
    1026         474 :     expand_table_name_patterns(fout, &tabledata_exclude_patterns,
    1027             :                                &tabledata_exclude_oids,
    1028             :                                false, false);
    1029         474 :     expand_table_name_patterns(fout, &tabledata_exclude_patterns_and_children,
    1030             :                                &tabledata_exclude_oids,
    1031             :                                false, true);
    1032             : 
    1033         474 :     expand_foreign_server_name_patterns(fout, &foreign_servers_include_patterns,
    1034             :                                         &foreign_servers_include_oids);
    1035             : 
    1036             :     /* non-matching exclusion patterns aren't an error */
    1037             : 
    1038             :     /* Expand extension selection patterns into OID lists */
    1039         472 :     if (extension_include_patterns.head != NULL)
    1040             :     {
    1041          10 :         expand_extension_name_patterns(fout, &extension_include_patterns,
    1042             :                                        &extension_include_oids,
    1043             :                                        strict_names);
    1044          10 :         if (extension_include_oids.head == NULL)
    1045           2 :             pg_fatal("no matching extensions were found");
    1046             :     }
    1047         470 :     expand_extension_name_patterns(fout, &extension_exclude_patterns,
    1048             :                                    &extension_exclude_oids,
    1049             :                                    false);
    1050             :     /* non-matching exclusion patterns aren't an error */
    1051             : 
    1052             :     /*
    1053             :      * Dumping LOs is the default for dumps where an inclusion switch is not
    1054             :      * used (an "include everything" dump).  -B can be used to exclude LOs
    1055             :      * from those dumps.  -b can be used to include LOs even when an inclusion
    1056             :      * switch is used.
    1057             :      *
    1058             :      * -s means "schema only" and LOs are data, not schema, so we never
    1059             :      * include LOs when -s is used.
    1060             :      */
    1061         470 :     if (dopt.include_everything && dopt.dumpData && !dopt.dontOutputLOs)
    1062         348 :         dopt.outputLOs = true;
    1063             : 
    1064             :     /*
    1065             :      * Collect role names so we can map object owner OIDs to names.
    1066             :      */
    1067         470 :     collectRoleNames(fout);
    1068             : 
    1069             :     /*
    1070             :      * Now scan the database and create DumpableObject structs for all the
    1071             :      * objects we intend to dump.
    1072             :      */
    1073         470 :     tblinfo = getSchemaData(fout, &numTables);
    1074             : 
    1075         468 :     if (dopt.dumpData)
    1076             :     {
    1077         396 :         getTableData(&dopt, tblinfo, numTables, 0);
    1078         396 :         buildMatViewRefreshDependencies(fout);
    1079         396 :         if (!dopt.dumpSchema)
    1080          14 :             getTableDataFKConstraints();
    1081             :     }
    1082             : 
    1083         468 :     if (!dopt.dumpData && dopt.sequence_data)
    1084          56 :         getTableData(&dopt, tblinfo, numTables, RELKIND_SEQUENCE);
    1085             : 
    1086             :     /*
    1087             :      * In binary-upgrade mode, we do not have to worry about the actual LO
    1088             :      * data or the associated metadata that resides in the pg_largeobject and
    1089             :      * pg_largeobject_metadata tables, respectively.
    1090             :      *
    1091             :      * However, we do need to collect LO information as there may be comments
    1092             :      * or other information on LOs that we do need to dump out.
    1093             :      */
    1094         468 :     if (dopt.outputLOs || dopt.binary_upgrade)
    1095         410 :         getLOs(fout);
    1096             : 
    1097             :     /*
    1098             :      * Collect dependency data to assist in ordering the objects.
    1099             :      */
    1100         468 :     getDependencies(fout);
    1101             : 
    1102             :     /*
    1103             :      * Collect ACLs, comments, and security labels, if wanted.
    1104             :      */
    1105         468 :     if (!dopt.aclsSkip)
    1106         464 :         getAdditionalACLs(fout);
    1107         468 :     if (!dopt.no_comments)
    1108         468 :         collectComments(fout);
    1109         468 :     if (!dopt.no_security_labels)
    1110         468 :         collectSecLabels(fout);
    1111             : 
    1112             :     /* For binary upgrade mode, collect required pg_class information. */
    1113         468 :     if (dopt.binary_upgrade)
    1114          62 :         collectBinaryUpgradeClassOids(fout);
    1115             : 
    1116             :     /* Collect sequence information. */
    1117         468 :     collectSequences(fout);
    1118             : 
    1119             :     /* Lastly, create dummy objects to represent the section boundaries */
    1120         468 :     boundaryObjs = createBoundaryObjects();
    1121             : 
    1122             :     /* Get pointers to all the known DumpableObjects */
    1123         468 :     getDumpableObjects(&dobjs, &numObjs);
    1124             : 
    1125             :     /*
    1126             :      * Add dummy dependencies to enforce the dump section ordering.
    1127             :      */
    1128         468 :     addBoundaryDependencies(dobjs, numObjs, boundaryObjs);
    1129             : 
    1130             :     /*
    1131             :      * Sort the objects into a safe dump order (no forward references).
    1132             :      *
    1133             :      * We rely on dependency information to help us determine a safe order, so
    1134             :      * the initial sort is mostly for cosmetic purposes: we sort by name to
    1135             :      * ensure that logically identical schemas will dump identically.
    1136             :      */
    1137         468 :     sortDumpableObjectsByTypeName(dobjs, numObjs);
    1138             : 
    1139         468 :     sortDumpableObjects(dobjs, numObjs,
    1140         468 :                         boundaryObjs[0].dumpId, boundaryObjs[1].dumpId);
    1141             : 
    1142             :     /*
    1143             :      * Create archive TOC entries for all the objects to be dumped, in a safe
    1144             :      * order.
    1145             :      */
    1146             : 
    1147             :     /*
    1148             :      * First the special entries for ENCODING, STDSTRINGS, and SEARCHPATH.
    1149             :      */
    1150         468 :     dumpEncoding(fout);
    1151         468 :     dumpStdStrings(fout);
    1152         468 :     dumpSearchPath(fout);
    1153             : 
    1154             :     /* The database items are always next, unless we don't want them at all */
    1155         468 :     if (dopt.outputCreateDB)
    1156         264 :         dumpDatabase(fout);
    1157             : 
    1158             :     /* Now the rearrangeable objects. */
    1159     1731722 :     for (i = 0; i < numObjs; i++)
    1160     1731254 :         dumpDumpableObject(fout, dobjs[i]);
    1161             : 
    1162             :     /*
    1163             :      * Set up options info to ensure we dump what we want.
    1164             :      */
    1165         468 :     ropt = NewRestoreOptions();
    1166         468 :     ropt->filename = filename;
    1167             : 
    1168             :     /* if you change this list, see dumpOptionsFromRestoreOptions */
    1169         468 :     ropt->cparams.dbname = dopt.cparams.dbname ? pg_strdup(dopt.cparams.dbname) : NULL;
    1170         468 :     ropt->cparams.pgport = dopt.cparams.pgport ? pg_strdup(dopt.cparams.pgport) : NULL;
    1171         468 :     ropt->cparams.pghost = dopt.cparams.pghost ? pg_strdup(dopt.cparams.pghost) : NULL;
    1172         468 :     ropt->cparams.username = dopt.cparams.username ? pg_strdup(dopt.cparams.username) : NULL;
    1173         468 :     ropt->cparams.promptPassword = dopt.cparams.promptPassword;
    1174         468 :     ropt->dropSchema = dopt.outputClean;
    1175         468 :     ropt->dumpData = dopt.dumpData;
    1176         468 :     ropt->dumpSchema = dopt.dumpSchema;
    1177         468 :     ropt->dumpStatistics = dopt.dumpStatistics;
    1178         468 :     ropt->if_exists = dopt.if_exists;
    1179         468 :     ropt->column_inserts = dopt.column_inserts;
    1180         468 :     ropt->dumpSections = dopt.dumpSections;
    1181         468 :     ropt->aclsSkip = dopt.aclsSkip;
    1182         468 :     ropt->superuser = dopt.outputSuperuser;
    1183         468 :     ropt->createDB = dopt.outputCreateDB;
    1184         468 :     ropt->noOwner = dopt.outputNoOwner;
    1185         468 :     ropt->noTableAm = dopt.outputNoTableAm;
    1186         468 :     ropt->noTablespace = dopt.outputNoTablespaces;
    1187         468 :     ropt->disable_triggers = dopt.disable_triggers;
    1188         468 :     ropt->use_setsessauth = dopt.use_setsessauth;
    1189         468 :     ropt->disable_dollar_quoting = dopt.disable_dollar_quoting;
    1190         468 :     ropt->dump_inserts = dopt.dump_inserts;
    1191         468 :     ropt->no_comments = dopt.no_comments;
    1192         468 :     ropt->no_policies = dopt.no_policies;
    1193         468 :     ropt->no_publications = dopt.no_publications;
    1194         468 :     ropt->no_security_labels = dopt.no_security_labels;
    1195         468 :     ropt->no_subscriptions = dopt.no_subscriptions;
    1196         468 :     ropt->lockWaitTimeout = dopt.lockWaitTimeout;
    1197         468 :     ropt->include_everything = dopt.include_everything;
    1198         468 :     ropt->enable_row_security = dopt.enable_row_security;
    1199         468 :     ropt->sequence_data = dopt.sequence_data;
    1200         468 :     ropt->binary_upgrade = dopt.binary_upgrade;
    1201             : 
    1202         468 :     ropt->compression_spec = compression_spec;
    1203             : 
    1204         468 :     ropt->suppressDumpWarnings = true;   /* We've already shown them */
    1205             : 
    1206         468 :     SetArchiveOptions(fout, &dopt, ropt);
    1207             : 
    1208             :     /* Mark which entries should be output */
    1209         468 :     ProcessArchiveRestoreOptions(fout);
    1210             : 
    1211             :     /*
    1212             :      * The archive's TOC entries are now marked as to which ones will actually
    1213             :      * be output, so we can set up their dependency lists properly. This isn't
    1214             :      * necessary for plain-text output, though.
    1215             :      */
    1216         468 :     if (!plainText)
    1217         206 :         BuildArchiveDependencies(fout);
    1218             : 
    1219             :     /*
    1220             :      * And finally we can do the actual output.
    1221             :      *
    1222             :      * Note: for non-plain-text output formats, the output file is written
    1223             :      * inside CloseArchive().  This is, um, bizarre; but not worth changing
    1224             :      * right now.
    1225             :      */
    1226         468 :     if (plainText)
    1227         262 :         RestoreArchive(fout, false);
    1228             : 
    1229         466 :     CloseArchive(fout);
    1230             : 
    1231         466 :     exit_nicely(0);
    1232             : }
    1233             : 
    1234             : 
    1235             : static void
    1236           2 : help(const char *progname)
    1237             : {
    1238           2 :     printf(_("%s dumps a database as a text file or to other formats.\n\n"), progname);
    1239           2 :     printf(_("Usage:\n"));
    1240           2 :     printf(_("  %s [OPTION]... [DBNAME]\n"), progname);
    1241             : 
    1242           2 :     printf(_("\nGeneral options:\n"));
    1243           2 :     printf(_("  -f, --file=FILENAME          output file or directory name\n"));
    1244           2 :     printf(_("  -F, --format=c|d|t|p         output file format (custom, directory, tar,\n"
    1245             :              "                               plain text (default))\n"));
    1246           2 :     printf(_("  -j, --jobs=NUM               use this many parallel jobs to dump\n"));
    1247           2 :     printf(_("  -v, --verbose                verbose mode\n"));
    1248           2 :     printf(_("  -V, --version                output version information, then exit\n"));
    1249           2 :     printf(_("  -Z, --compress=METHOD[:DETAIL]\n"
    1250             :              "                               compress as specified\n"));
    1251           2 :     printf(_("  --lock-wait-timeout=TIMEOUT  fail after waiting TIMEOUT for a table lock\n"));
    1252           2 :     printf(_("  --no-sync                    do not wait for changes to be written safely to disk\n"));
    1253           2 :     printf(_("  --sync-method=METHOD         set method for syncing files to disk\n"));
    1254           2 :     printf(_("  -?, --help                   show this help, then exit\n"));
    1255             : 
    1256           2 :     printf(_("\nOptions controlling the output content:\n"));
    1257           2 :     printf(_("  -a, --data-only              dump only the data, not the schema or statistics\n"));
    1258           2 :     printf(_("  -b, --large-objects          include large objects in dump\n"));
    1259           2 :     printf(_("  --blobs                      (same as --large-objects, deprecated)\n"));
    1260           2 :     printf(_("  -B, --no-large-objects       exclude large objects in dump\n"));
    1261           2 :     printf(_("  --no-blobs                   (same as --no-large-objects, deprecated)\n"));
    1262           2 :     printf(_("  -c, --clean                  clean (drop) database objects before recreating\n"));
    1263           2 :     printf(_("  -C, --create                 include commands to create database in dump\n"));
    1264           2 :     printf(_("  -e, --extension=PATTERN      dump the specified extension(s) only\n"));
    1265           2 :     printf(_("  -E, --encoding=ENCODING      dump the data in encoding ENCODING\n"));
    1266           2 :     printf(_("  -n, --schema=PATTERN         dump the specified schema(s) only\n"));
    1267           2 :     printf(_("  -N, --exclude-schema=PATTERN do NOT dump the specified schema(s)\n"));
    1268           2 :     printf(_("  -O, --no-owner               skip restoration of object ownership in\n"
    1269             :              "                               plain-text format\n"));
    1270           2 :     printf(_("  -s, --schema-only            dump only the schema, no data or statistics\n"));
    1271           2 :     printf(_("  -S, --superuser=NAME         superuser user name to use in plain-text format\n"));
    1272           2 :     printf(_("  -t, --table=PATTERN          dump only the specified table(s)\n"));
    1273           2 :     printf(_("  -T, --exclude-table=PATTERN  do NOT dump the specified table(s)\n"));
    1274           2 :     printf(_("  -x, --no-privileges          do not dump privileges (grant/revoke)\n"));
    1275           2 :     printf(_("  --binary-upgrade             for use by upgrade utilities only\n"));
    1276           2 :     printf(_("  --column-inserts             dump data as INSERT commands with column names\n"));
    1277           2 :     printf(_("  --disable-dollar-quoting     disable dollar quoting, use SQL standard quoting\n"));
    1278           2 :     printf(_("  --disable-triggers           disable triggers during data-only restore\n"));
    1279           2 :     printf(_("  --enable-row-security        enable row security (dump only content user has\n"
    1280             :              "                               access to)\n"));
    1281           2 :     printf(_("  --exclude-extension=PATTERN  do NOT dump the specified extension(s)\n"));
    1282           2 :     printf(_("  --exclude-table-and-children=PATTERN\n"
    1283             :              "                               do NOT dump the specified table(s), including\n"
    1284             :              "                               child and partition tables\n"));
    1285           2 :     printf(_("  --exclude-table-data=PATTERN do NOT dump data for the specified table(s)\n"));
    1286           2 :     printf(_("  --exclude-table-data-and-children=PATTERN\n"
    1287             :              "                               do NOT dump data for the specified table(s),\n"
    1288             :              "                               including child and partition tables\n"));
    1289           2 :     printf(_("  --extra-float-digits=NUM     override default setting for extra_float_digits\n"));
    1290           2 :     printf(_("  --filter=FILENAME            include or exclude objects and data from dump\n"
    1291             :              "                               based on expressions in FILENAME\n"));
    1292           2 :     printf(_("  --if-exists                  use IF EXISTS when dropping objects\n"));
    1293           2 :     printf(_("  --include-foreign-data=PATTERN\n"
    1294             :              "                               include data of foreign tables on foreign\n"
    1295             :              "                               servers matching PATTERN\n"));
    1296           2 :     printf(_("  --inserts                    dump data as INSERT commands, rather than COPY\n"));
    1297           2 :     printf(_("  --load-via-partition-root    load partitions via the root table\n"));
    1298           2 :     printf(_("  --no-comments                do not dump comment commands\n"));
    1299           2 :     printf(_("  --no-data                    do not dump data\n"));
    1300           2 :     printf(_("  --no-policies                do not dump row security policies\n"));
    1301           2 :     printf(_("  --no-publications            do not dump publications\n"));
    1302           2 :     printf(_("  --no-schema                  do not dump schema\n"));
    1303           2 :     printf(_("  --no-security-labels         do not dump security label assignments\n"));
    1304           2 :     printf(_("  --no-statistics              do not dump statistics\n"));
    1305           2 :     printf(_("  --no-subscriptions           do not dump subscriptions\n"));
    1306           2 :     printf(_("  --no-table-access-method     do not dump table access methods\n"));
    1307           2 :     printf(_("  --no-tablespaces             do not dump tablespace assignments\n"));
    1308           2 :     printf(_("  --no-toast-compression       do not dump TOAST compression methods\n"));
    1309           2 :     printf(_("  --no-unlogged-table-data     do not dump unlogged table data\n"));
    1310           2 :     printf(_("  --on-conflict-do-nothing     add ON CONFLICT DO NOTHING to INSERT commands\n"));
    1311           2 :     printf(_("  --quote-all-identifiers      quote all identifiers, even if not key words\n"));
    1312           2 :     printf(_("  --rows-per-insert=NROWS      number of rows per INSERT; implies --inserts\n"));
    1313           2 :     printf(_("  --section=SECTION            dump named section (pre-data, data, or post-data)\n"));
    1314           2 :     printf(_("  --sequence-data              include sequence data in dump\n"));
    1315           2 :     printf(_("  --serializable-deferrable    wait until the dump can run without anomalies\n"));
    1316           2 :     printf(_("  --snapshot=SNAPSHOT          use given snapshot for the dump\n"));
    1317           2 :     printf(_("  --statistics-only            dump only the statistics, not schema or data\n"));
    1318           2 :     printf(_("  --strict-names               require table and/or schema include patterns to\n"
    1319             :              "                               match at least one entity each\n"));
    1320           2 :     printf(_("  --table-and-children=PATTERN dump only the specified table(s), including\n"
    1321             :              "                               child and partition tables\n"));
    1322           2 :     printf(_("  --use-set-session-authorization\n"
    1323             :              "                               use SET SESSION AUTHORIZATION commands instead of\n"
    1324             :              "                               ALTER OWNER commands to set ownership\n"));
    1325           2 :     printf(_("  --with-data                  dump the data\n"));
    1326           2 :     printf(_("  --with-schema                dump the schema\n"));
    1327           2 :     printf(_("  --with-statistics            dump the statistics\n"));
    1328             : 
    1329           2 :     printf(_("\nConnection options:\n"));
    1330           2 :     printf(_("  -d, --dbname=DBNAME      database to dump\n"));
    1331           2 :     printf(_("  -h, --host=HOSTNAME      database server host or socket directory\n"));
    1332           2 :     printf(_("  -p, --port=PORT          database server port number\n"));
    1333           2 :     printf(_("  -U, --username=NAME      connect as specified database user\n"));
    1334           2 :     printf(_("  -w, --no-password        never prompt for password\n"));
    1335           2 :     printf(_("  -W, --password           force password prompt (should happen automatically)\n"));
    1336           2 :     printf(_("  --role=ROLENAME          do SET ROLE before dump\n"));
    1337             : 
    1338           2 :     printf(_("\nIf no database name is supplied, then the PGDATABASE environment\n"
    1339             :              "variable value is used.\n\n"));
    1340           2 :     printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
    1341           2 :     printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
    1342           2 : }
    1343             : 
    1344             : static void
    1345         538 : setup_connection(Archive *AH, const char *dumpencoding,
    1346             :                  const char *dumpsnapshot, char *use_role)
    1347             : {
    1348         538 :     DumpOptions *dopt = AH->dopt;
    1349         538 :     PGconn     *conn = GetConnection(AH);
    1350             :     const char *std_strings;
    1351             : 
    1352         538 :     PQclear(ExecuteSqlQueryForSingleRow(AH, ALWAYS_SECURE_SEARCH_PATH_SQL));
    1353             : 
    1354             :     /*
    1355             :      * Set the client encoding if requested.
    1356             :      */
    1357         538 :     if (dumpencoding)
    1358             :     {
    1359          40 :         if (PQsetClientEncoding(conn, dumpencoding) < 0)
    1360           0 :             pg_fatal("invalid client encoding \"%s\" specified",
    1361             :                      dumpencoding);
    1362             :     }
    1363             : 
    1364             :     /*
    1365             :      * Get the active encoding and the standard_conforming_strings setting, so
    1366             :      * we know how to escape strings.
    1367             :      */
    1368         538 :     AH->encoding = PQclientEncoding(conn);
    1369         538 :     setFmtEncoding(AH->encoding);
    1370             : 
    1371         538 :     std_strings = PQparameterStatus(conn, "standard_conforming_strings");
    1372         538 :     AH->std_strings = (std_strings && strcmp(std_strings, "on") == 0);
    1373             : 
    1374             :     /*
    1375             :      * Set the role if requested.  In a parallel dump worker, we'll be passed
    1376             :      * use_role == NULL, but AH->use_role is already set (if user specified it
    1377             :      * originally) and we should use that.
    1378             :      */
    1379         538 :     if (!use_role && AH->use_role)
    1380           4 :         use_role = AH->use_role;
    1381             : 
    1382             :     /* Set the role if requested */
    1383         538 :     if (use_role)
    1384             :     {
    1385          10 :         PQExpBuffer query = createPQExpBuffer();
    1386             : 
    1387          10 :         appendPQExpBuffer(query, "SET ROLE %s", fmtId(use_role));
    1388          10 :         ExecuteSqlStatement(AH, query->data);
    1389          10 :         destroyPQExpBuffer(query);
    1390             : 
    1391             :         /* save it for possible later use by parallel workers */
    1392          10 :         if (!AH->use_role)
    1393           6 :             AH->use_role = pg_strdup(use_role);
    1394             :     }
    1395             : 
    1396             :     /* Set the datestyle to ISO to ensure the dump's portability */
    1397         538 :     ExecuteSqlStatement(AH, "SET DATESTYLE = ISO");
    1398             : 
    1399             :     /* Likewise, avoid using sql_standard intervalstyle */
    1400         538 :     ExecuteSqlStatement(AH, "SET INTERVALSTYLE = POSTGRES");
    1401             : 
    1402             :     /*
    1403             :      * Use an explicitly specified extra_float_digits if it has been provided.
    1404             :      * Otherwise, set extra_float_digits so that we can dump float data
    1405             :      * exactly (given correctly implemented float I/O code, anyway).
    1406             :      */
    1407         538 :     if (have_extra_float_digits)
    1408             :     {
    1409           0 :         PQExpBuffer q = createPQExpBuffer();
    1410             : 
    1411           0 :         appendPQExpBuffer(q, "SET extra_float_digits TO %d",
    1412             :                           extra_float_digits);
    1413           0 :         ExecuteSqlStatement(AH, q->data);
    1414           0 :         destroyPQExpBuffer(q);
    1415             :     }
    1416             :     else
    1417         538 :         ExecuteSqlStatement(AH, "SET extra_float_digits TO 3");
    1418             : 
    1419             :     /*
    1420             :      * Disable synchronized scanning, to prevent unpredictable changes in row
    1421             :      * ordering across a dump and reload.
    1422             :      */
    1423         538 :     ExecuteSqlStatement(AH, "SET synchronize_seqscans TO off");
    1424             : 
    1425             :     /*
    1426             :      * Disable timeouts if supported.
    1427             :      */
    1428         538 :     ExecuteSqlStatement(AH, "SET statement_timeout = 0");
    1429         538 :     if (AH->remoteVersion >= 90300)
    1430         538 :         ExecuteSqlStatement(AH, "SET lock_timeout = 0");
    1431         538 :     if (AH->remoteVersion >= 90600)
    1432         538 :         ExecuteSqlStatement(AH, "SET idle_in_transaction_session_timeout = 0");
    1433         538 :     if (AH->remoteVersion >= 170000)
    1434         538 :         ExecuteSqlStatement(AH, "SET transaction_timeout = 0");
    1435             : 
    1436             :     /*
    1437             :      * Quote all identifiers, if requested.
    1438             :      */
    1439         538 :     if (quote_all_identifiers)
    1440          58 :         ExecuteSqlStatement(AH, "SET quote_all_identifiers = true");
    1441             : 
    1442             :     /*
    1443             :      * Adjust row-security mode, if supported.
    1444             :      */
    1445         538 :     if (AH->remoteVersion >= 90500)
    1446             :     {
    1447         538 :         if (dopt->enable_row_security)
    1448           0 :             ExecuteSqlStatement(AH, "SET row_security = on");
    1449             :         else
    1450         538 :             ExecuteSqlStatement(AH, "SET row_security = off");
    1451             :     }
    1452             : 
    1453             :     /*
    1454             :      * For security reasons, we restrict the expansion of non-system views and
    1455             :      * access to foreign tables during the pg_dump process. This restriction
    1456             :      * is adjusted when dumping foreign table data.
    1457             :      */
    1458         538 :     set_restrict_relation_kind(AH, "view, foreign-table");
    1459             : 
    1460             :     /*
    1461             :      * Initialize prepared-query state to "nothing prepared".  We do this here
    1462             :      * so that a parallel dump worker will have its own state.
    1463             :      */
    1464         538 :     AH->is_prepared = (bool *) pg_malloc0(NUM_PREP_QUERIES * sizeof(bool));
    1465             : 
    1466             :     /*
    1467             :      * Start transaction-snapshot mode transaction to dump consistent data.
    1468             :      */
    1469         538 :     ExecuteSqlStatement(AH, "BEGIN");
    1470             : 
    1471             :     /*
    1472             :      * To support the combination of serializable_deferrable with the jobs
    1473             :      * option we use REPEATABLE READ for the worker connections that are
    1474             :      * passed a snapshot.  As long as the snapshot is acquired in a
    1475             :      * SERIALIZABLE, READ ONLY, DEFERRABLE transaction, its use within a
    1476             :      * REPEATABLE READ transaction provides the appropriate integrity
    1477             :      * guarantees.  This is a kluge, but safe for back-patching.
    1478             :      */
    1479         538 :     if (dopt->serializable_deferrable && AH->sync_snapshot_id == NULL)
    1480           0 :         ExecuteSqlStatement(AH,
    1481             :                             "SET TRANSACTION ISOLATION LEVEL "
    1482             :                             "SERIALIZABLE, READ ONLY, DEFERRABLE");
    1483             :     else
    1484         538 :         ExecuteSqlStatement(AH,
    1485             :                             "SET TRANSACTION ISOLATION LEVEL "
    1486             :                             "REPEATABLE READ, READ ONLY");
    1487             : 
    1488             :     /*
    1489             :      * If user specified a snapshot to use, select that.  In a parallel dump
    1490             :      * worker, we'll be passed dumpsnapshot == NULL, but AH->sync_snapshot_id
    1491             :      * is already set (if the server can handle it) and we should use that.
    1492             :      */
    1493         538 :     if (dumpsnapshot)
    1494           0 :         AH->sync_snapshot_id = pg_strdup(dumpsnapshot);
    1495             : 
    1496         538 :     if (AH->sync_snapshot_id)
    1497             :     {
    1498          36 :         PQExpBuffer query = createPQExpBuffer();
    1499             : 
    1500          36 :         appendPQExpBufferStr(query, "SET TRANSACTION SNAPSHOT ");
    1501          36 :         appendStringLiteralConn(query, AH->sync_snapshot_id, conn);
    1502          36 :         ExecuteSqlStatement(AH, query->data);
    1503          36 :         destroyPQExpBuffer(query);
    1504             :     }
    1505         502 :     else if (AH->numWorkers > 1)
    1506             :     {
    1507          18 :         if (AH->isStandby && AH->remoteVersion < 100000)
    1508           0 :             pg_fatal("parallel dumps from standby servers are not supported by this server version");
    1509          18 :         AH->sync_snapshot_id = get_synchronized_snapshot(AH);
    1510             :     }
    1511         538 : }
    1512             : 
    1513             : /* Set up connection for a parallel worker process */
    1514             : static void
    1515          36 : setupDumpWorker(Archive *AH)
    1516             : {
    1517             :     /*
    1518             :      * We want to re-select all the same values the leader connection is
    1519             :      * using.  We'll have inherited directly-usable values in
    1520             :      * AH->sync_snapshot_id and AH->use_role, but we need to translate the
    1521             :      * inherited encoding value back to a string to pass to setup_connection.
    1522             :      */
    1523          36 :     setup_connection(AH,
    1524             :                      pg_encoding_to_char(AH->encoding),
    1525             :                      NULL,
    1526             :                      NULL);
    1527          36 : }
    1528             : 
    1529             : static char *
    1530          18 : get_synchronized_snapshot(Archive *fout)
    1531             : {
    1532          18 :     char       *query = "SELECT pg_catalog.pg_export_snapshot()";
    1533             :     char       *result;
    1534             :     PGresult   *res;
    1535             : 
    1536          18 :     res = ExecuteSqlQueryForSingleRow(fout, query);
    1537          18 :     result = pg_strdup(PQgetvalue(res, 0, 0));
    1538          18 :     PQclear(res);
    1539             : 
    1540          18 :     return result;
    1541             : }
    1542             : 
    1543             : static ArchiveFormat
    1544         520 : parseArchiveFormat(const char *format, ArchiveMode *mode)
    1545             : {
    1546             :     ArchiveFormat archiveFormat;
    1547             : 
    1548         520 :     *mode = archModeWrite;
    1549             : 
    1550         520 :     if (pg_strcasecmp(format, "a") == 0 || pg_strcasecmp(format, "append") == 0)
    1551             :     {
    1552             :         /* This is used by pg_dumpall, and is not documented */
    1553          86 :         archiveFormat = archNull;
    1554          86 :         *mode = archModeAppend;
    1555             :     }
    1556         434 :     else if (pg_strcasecmp(format, "c") == 0)
    1557           0 :         archiveFormat = archCustom;
    1558         434 :     else if (pg_strcasecmp(format, "custom") == 0)
    1559          88 :         archiveFormat = archCustom;
    1560         346 :     else if (pg_strcasecmp(format, "d") == 0)
    1561           2 :         archiveFormat = archDirectory;
    1562         344 :     else if (pg_strcasecmp(format, "directory") == 0)
    1563          96 :         archiveFormat = archDirectory;
    1564         248 :     else if (pg_strcasecmp(format, "p") == 0)
    1565         218 :         archiveFormat = archNull;
    1566          30 :     else if (pg_strcasecmp(format, "plain") == 0)
    1567           6 :         archiveFormat = archNull;
    1568          24 :     else if (pg_strcasecmp(format, "t") == 0)
    1569           0 :         archiveFormat = archTar;
    1570          24 :     else if (pg_strcasecmp(format, "tar") == 0)
    1571          22 :         archiveFormat = archTar;
    1572             :     else
    1573           2 :         pg_fatal("invalid output format \"%s\" specified", format);
    1574         518 :     return archiveFormat;
    1575             : }
    1576             : 
    1577             : /*
    1578             :  * Find the OIDs of all schemas matching the given list of patterns,
    1579             :  * and append them to the given OID list.
    1580             :  */
    1581             : static void
    1582         524 : expand_schema_name_patterns(Archive *fout,
    1583             :                             SimpleStringList *patterns,
    1584             :                             SimpleOidList *oids,
    1585             :                             bool strict_names)
    1586             : {
    1587             :     PQExpBuffer query;
    1588             :     PGresult   *res;
    1589             :     SimpleStringListCell *cell;
    1590             :     int         i;
    1591             : 
    1592         524 :     if (patterns->head == NULL)
    1593         482 :         return;                 /* nothing to do */
    1594             : 
    1595          42 :     query = createPQExpBuffer();
    1596             : 
    1597             :     /*
    1598             :      * The loop below runs multiple SELECTs might sometimes result in
    1599             :      * duplicate entries in the OID list, but we don't care.
    1600             :      */
    1601             : 
    1602          72 :     for (cell = patterns->head; cell; cell = cell->next)
    1603             :     {
    1604             :         PQExpBufferData dbbuf;
    1605             :         int         dotcnt;
    1606             : 
    1607          42 :         appendPQExpBufferStr(query,
    1608             :                              "SELECT oid FROM pg_catalog.pg_namespace n\n");
    1609          42 :         initPQExpBuffer(&dbbuf);
    1610          42 :         processSQLNamePattern(GetConnection(fout), query, cell->val, false,
    1611             :                               false, NULL, "n.nspname", NULL, NULL, &dbbuf,
    1612             :                               &dotcnt);
    1613          42 :         if (dotcnt > 1)
    1614           4 :             pg_fatal("improper qualified name (too many dotted names): %s",
    1615             :                      cell->val);
    1616          38 :         else if (dotcnt == 1)
    1617           6 :             prohibit_crossdb_refs(GetConnection(fout), dbbuf.data, cell->val);
    1618          32 :         termPQExpBuffer(&dbbuf);
    1619             : 
    1620          32 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    1621          32 :         if (strict_names && PQntuples(res) == 0)
    1622           2 :             pg_fatal("no matching schemas were found for pattern \"%s\"", cell->val);
    1623             : 
    1624          58 :         for (i = 0; i < PQntuples(res); i++)
    1625             :         {
    1626          28 :             simple_oid_list_append(oids, atooid(PQgetvalue(res, i, 0)));
    1627             :         }
    1628             : 
    1629          30 :         PQclear(res);
    1630          30 :         resetPQExpBuffer(query);
    1631             :     }
    1632             : 
    1633          30 :     destroyPQExpBuffer(query);
    1634             : }
    1635             : 
    1636             : /*
    1637             :  * Find the OIDs of all extensions matching the given list of patterns,
    1638             :  * and append them to the given OID list.
    1639             :  */
    1640             : static void
    1641         480 : expand_extension_name_patterns(Archive *fout,
    1642             :                                SimpleStringList *patterns,
    1643             :                                SimpleOidList *oids,
    1644             :                                bool strict_names)
    1645             : {
    1646             :     PQExpBuffer query;
    1647             :     PGresult   *res;
    1648             :     SimpleStringListCell *cell;
    1649             :     int         i;
    1650             : 
    1651         480 :     if (patterns->head == NULL)
    1652         466 :         return;                 /* nothing to do */
    1653             : 
    1654          14 :     query = createPQExpBuffer();
    1655             : 
    1656             :     /*
    1657             :      * The loop below runs multiple SELECTs might sometimes result in
    1658             :      * duplicate entries in the OID list, but we don't care.
    1659             :      */
    1660          28 :     for (cell = patterns->head; cell; cell = cell->next)
    1661             :     {
    1662             :         int         dotcnt;
    1663             : 
    1664          14 :         appendPQExpBufferStr(query,
    1665             :                              "SELECT oid FROM pg_catalog.pg_extension e\n");
    1666          14 :         processSQLNamePattern(GetConnection(fout), query, cell->val, false,
    1667             :                               false, NULL, "e.extname", NULL, NULL, NULL,
    1668             :                               &dotcnt);
    1669          14 :         if (dotcnt > 0)
    1670           0 :             pg_fatal("improper qualified name (too many dotted names): %s",
    1671             :                      cell->val);
    1672             : 
    1673          14 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    1674          14 :         if (strict_names && PQntuples(res) == 0)
    1675           0 :             pg_fatal("no matching extensions were found for pattern \"%s\"", cell->val);
    1676             : 
    1677          26 :         for (i = 0; i < PQntuples(res); i++)
    1678             :         {
    1679          12 :             simple_oid_list_append(oids, atooid(PQgetvalue(res, i, 0)));
    1680             :         }
    1681             : 
    1682          14 :         PQclear(res);
    1683          14 :         resetPQExpBuffer(query);
    1684             :     }
    1685             : 
    1686          14 :     destroyPQExpBuffer(query);
    1687             : }
    1688             : 
    1689             : /*
    1690             :  * Find the OIDs of all foreign servers matching the given list of patterns,
    1691             :  * and append them to the given OID list.
    1692             :  */
    1693             : static void
    1694         474 : expand_foreign_server_name_patterns(Archive *fout,
    1695             :                                     SimpleStringList *patterns,
    1696             :                                     SimpleOidList *oids)
    1697             : {
    1698             :     PQExpBuffer query;
    1699             :     PGresult   *res;
    1700             :     SimpleStringListCell *cell;
    1701             :     int         i;
    1702             : 
    1703         474 :     if (patterns->head == NULL)
    1704         468 :         return;                 /* nothing to do */
    1705             : 
    1706           6 :     query = createPQExpBuffer();
    1707             : 
    1708             :     /*
    1709             :      * The loop below runs multiple SELECTs might sometimes result in
    1710             :      * duplicate entries in the OID list, but we don't care.
    1711             :      */
    1712             : 
    1713          10 :     for (cell = patterns->head; cell; cell = cell->next)
    1714             :     {
    1715             :         int         dotcnt;
    1716             : 
    1717           6 :         appendPQExpBufferStr(query,
    1718             :                              "SELECT oid FROM pg_catalog.pg_foreign_server s\n");
    1719           6 :         processSQLNamePattern(GetConnection(fout), query, cell->val, false,
    1720             :                               false, NULL, "s.srvname", NULL, NULL, NULL,
    1721             :                               &dotcnt);
    1722           6 :         if (dotcnt > 0)
    1723           0 :             pg_fatal("improper qualified name (too many dotted names): %s",
    1724             :                      cell->val);
    1725             : 
    1726           6 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    1727           6 :         if (PQntuples(res) == 0)
    1728           2 :             pg_fatal("no matching foreign servers were found for pattern \"%s\"", cell->val);
    1729             : 
    1730           8 :         for (i = 0; i < PQntuples(res); i++)
    1731           4 :             simple_oid_list_append(oids, atooid(PQgetvalue(res, i, 0)));
    1732             : 
    1733           4 :         PQclear(res);
    1734           4 :         resetPQExpBuffer(query);
    1735             :     }
    1736             : 
    1737           4 :     destroyPQExpBuffer(query);
    1738             : }
    1739             : 
    1740             : /*
    1741             :  * Find the OIDs of all tables matching the given list of patterns,
    1742             :  * and append them to the given OID list. See also expand_dbname_patterns()
    1743             :  * in pg_dumpall.c
    1744             :  */
    1745             : static void
    1746        2862 : expand_table_name_patterns(Archive *fout,
    1747             :                            SimpleStringList *patterns, SimpleOidList *oids,
    1748             :                            bool strict_names, bool with_child_tables)
    1749             : {
    1750             :     PQExpBuffer query;
    1751             :     PGresult   *res;
    1752             :     SimpleStringListCell *cell;
    1753             :     int         i;
    1754             : 
    1755        2862 :     if (patterns->head == NULL)
    1756        2804 :         return;                 /* nothing to do */
    1757             : 
    1758          58 :     query = createPQExpBuffer();
    1759             : 
    1760             :     /*
    1761             :      * this might sometimes result in duplicate entries in the OID list, but
    1762             :      * we don't care.
    1763             :      */
    1764             : 
    1765         118 :     for (cell = patterns->head; cell; cell = cell->next)
    1766             :     {
    1767             :         PQExpBufferData dbbuf;
    1768             :         int         dotcnt;
    1769             : 
    1770             :         /*
    1771             :          * Query must remain ABSOLUTELY devoid of unqualified names.  This
    1772             :          * would be unnecessary given a pg_table_is_visible() variant taking a
    1773             :          * search_path argument.
    1774             :          *
    1775             :          * For with_child_tables, we start with the basic query's results and
    1776             :          * recursively search the inheritance tree to add child tables.
    1777             :          */
    1778          70 :         if (with_child_tables)
    1779             :         {
    1780          12 :             appendPQExpBufferStr(query, "WITH RECURSIVE partition_tree (relid) AS (\n");
    1781             :         }
    1782             : 
    1783          70 :         appendPQExpBuffer(query,
    1784             :                           "SELECT c.oid"
    1785             :                           "\nFROM pg_catalog.pg_class c"
    1786             :                           "\n     LEFT JOIN pg_catalog.pg_namespace n"
    1787             :                           "\n     ON n.oid OPERATOR(pg_catalog.=) c.relnamespace"
    1788             :                           "\nWHERE c.relkind OPERATOR(pg_catalog.=) ANY"
    1789             :                           "\n    (array['%c', '%c', '%c', '%c', '%c', '%c'])\n",
    1790             :                           RELKIND_RELATION, RELKIND_SEQUENCE, RELKIND_VIEW,
    1791             :                           RELKIND_MATVIEW, RELKIND_FOREIGN_TABLE,
    1792             :                           RELKIND_PARTITIONED_TABLE);
    1793          70 :         initPQExpBuffer(&dbbuf);
    1794          70 :         processSQLNamePattern(GetConnection(fout), query, cell->val, true,
    1795             :                               false, "n.nspname", "c.relname", NULL,
    1796             :                               "pg_catalog.pg_table_is_visible(c.oid)", &dbbuf,
    1797             :                               &dotcnt);
    1798          70 :         if (dotcnt > 2)
    1799           2 :             pg_fatal("improper relation name (too many dotted names): %s",
    1800             :                      cell->val);
    1801          68 :         else if (dotcnt == 2)
    1802           4 :             prohibit_crossdb_refs(GetConnection(fout), dbbuf.data, cell->val);
    1803          64 :         termPQExpBuffer(&dbbuf);
    1804             : 
    1805          64 :         if (with_child_tables)
    1806             :         {
    1807          12 :             appendPQExpBufferStr(query, "UNION"
    1808             :                                  "\nSELECT i.inhrelid"
    1809             :                                  "\nFROM partition_tree p"
    1810             :                                  "\n     JOIN pg_catalog.pg_inherits i"
    1811             :                                  "\n     ON p.relid OPERATOR(pg_catalog.=) i.inhparent"
    1812             :                                  "\n)"
    1813             :                                  "\nSELECT relid FROM partition_tree");
    1814             :         }
    1815             : 
    1816          64 :         ExecuteSqlStatement(fout, "RESET search_path");
    1817          64 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    1818          64 :         PQclear(ExecuteSqlQueryForSingleRow(fout,
    1819             :                                             ALWAYS_SECURE_SEARCH_PATH_SQL));
    1820          64 :         if (strict_names && PQntuples(res) == 0)
    1821           4 :             pg_fatal("no matching tables were found for pattern \"%s\"", cell->val);
    1822             : 
    1823         148 :         for (i = 0; i < PQntuples(res); i++)
    1824             :         {
    1825          88 :             simple_oid_list_append(oids, atooid(PQgetvalue(res, i, 0)));
    1826             :         }
    1827             : 
    1828          60 :         PQclear(res);
    1829          60 :         resetPQExpBuffer(query);
    1830             :     }
    1831             : 
    1832          48 :     destroyPQExpBuffer(query);
    1833             : }
    1834             : 
    1835             : /*
    1836             :  * Verifies that the connected database name matches the given database name,
    1837             :  * and if not, dies with an error about the given pattern.
    1838             :  *
    1839             :  * The 'dbname' argument should be a literal name parsed from 'pattern'.
    1840             :  */
    1841             : static void
    1842          10 : prohibit_crossdb_refs(PGconn *conn, const char *dbname, const char *pattern)
    1843             : {
    1844             :     const char *db;
    1845             : 
    1846          10 :     db = PQdb(conn);
    1847          10 :     if (db == NULL)
    1848           0 :         pg_fatal("You are currently not connected to a database.");
    1849             : 
    1850          10 :     if (strcmp(db, dbname) != 0)
    1851          10 :         pg_fatal("cross-database references are not implemented: %s",
    1852             :                  pattern);
    1853           0 : }
    1854             : 
    1855             : /*
    1856             :  * checkExtensionMembership
    1857             :  *      Determine whether object is an extension member, and if so,
    1858             :  *      record an appropriate dependency and set the object's dump flag.
    1859             :  *
    1860             :  * It's important to call this for each object that could be an extension
    1861             :  * member.  Generally, we integrate this with determining the object's
    1862             :  * to-be-dumped-ness, since extension membership overrides other rules for that.
    1863             :  *
    1864             :  * Returns true if object is an extension member, else false.
    1865             :  */
    1866             : static bool
    1867     1459184 : checkExtensionMembership(DumpableObject *dobj, Archive *fout)
    1868             : {
    1869     1459184 :     ExtensionInfo *ext = findOwningExtension(dobj->catId);
    1870             : 
    1871     1459184 :     if (ext == NULL)
    1872     1457530 :         return false;
    1873             : 
    1874        1654 :     dobj->ext_member = true;
    1875             : 
    1876             :     /* Record dependency so that getDependencies needn't deal with that */
    1877        1654 :     addObjectDependency(dobj, ext->dobj.dumpId);
    1878             : 
    1879             :     /*
    1880             :      * In 9.6 and above, mark the member object to have any non-initial ACLs
    1881             :      * dumped.  (Any initial ACLs will be removed later, using data from
    1882             :      * pg_init_privs, so that we'll dump only the delta from the extension's
    1883             :      * initial setup.)
    1884             :      *
    1885             :      * Prior to 9.6, we do not include any extension member components.
    1886             :      *
    1887             :      * In binary upgrades, we still dump all components of the members
    1888             :      * individually, since the idea is to exactly reproduce the database
    1889             :      * contents rather than replace the extension contents with something
    1890             :      * different.
    1891             :      *
    1892             :      * Note: it might be interesting someday to implement storage and delta
    1893             :      * dumping of extension members' RLS policies and/or security labels.
    1894             :      * However there is a pitfall for RLS policies: trying to dump them
    1895             :      * requires getting a lock on their tables, and the calling user might not
    1896             :      * have privileges for that.  We need no lock to examine a table's ACLs,
    1897             :      * so the current feature doesn't have a problem of that sort.
    1898             :      */
    1899        1654 :     if (fout->dopt->binary_upgrade)
    1900         288 :         dobj->dump = ext->dobj.dump;
    1901             :     else
    1902             :     {
    1903        1366 :         if (fout->remoteVersion < 90600)
    1904           0 :             dobj->dump = DUMP_COMPONENT_NONE;
    1905             :         else
    1906        1366 :             dobj->dump = ext->dobj.dump_contains & (DUMP_COMPONENT_ACL);
    1907             :     }
    1908             : 
    1909        1654 :     return true;
    1910             : }
    1911             : 
    1912             : /*
    1913             :  * selectDumpableNamespace: policy-setting subroutine
    1914             :  *      Mark a namespace as to be dumped or not
    1915             :  */
    1916             : static void
    1917        3788 : selectDumpableNamespace(NamespaceInfo *nsinfo, Archive *fout)
    1918             : {
    1919             :     /*
    1920             :      * DUMP_COMPONENT_DEFINITION typically implies a CREATE SCHEMA statement
    1921             :      * and (for --clean) a DROP SCHEMA statement.  (In the absence of
    1922             :      * DUMP_COMPONENT_DEFINITION, this value is irrelevant.)
    1923             :      */
    1924        3788 :     nsinfo->create = true;
    1925             : 
    1926             :     /*
    1927             :      * If specific tables are being dumped, do not dump any complete
    1928             :      * namespaces. If specific namespaces are being dumped, dump just those
    1929             :      * namespaces. Otherwise, dump all non-system namespaces.
    1930             :      */
    1931        3788 :     if (table_include_oids.head != NULL)
    1932         100 :         nsinfo->dobj.dump_contains = nsinfo->dobj.dump = DUMP_COMPONENT_NONE;
    1933        3688 :     else if (schema_include_oids.head != NULL)
    1934         342 :         nsinfo->dobj.dump_contains = nsinfo->dobj.dump =
    1935         342 :             simple_oid_list_member(&schema_include_oids,
    1936             :                                    nsinfo->dobj.catId.oid) ?
    1937         342 :             DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    1938        3346 :     else if (fout->remoteVersion >= 90600 &&
    1939        3346 :              strcmp(nsinfo->dobj.name, "pg_catalog") == 0)
    1940             :     {
    1941             :         /*
    1942             :          * In 9.6 and above, we dump out any ACLs defined in pg_catalog, if
    1943             :          * they are interesting (and not the original ACLs which were set at
    1944             :          * initdb time, see pg_init_privs).
    1945             :          */
    1946         426 :         nsinfo->dobj.dump_contains = nsinfo->dobj.dump = DUMP_COMPONENT_ACL;
    1947             :     }
    1948        2920 :     else if (strncmp(nsinfo->dobj.name, "pg_", 3) == 0 ||
    1949        1254 :              strcmp(nsinfo->dobj.name, "information_schema") == 0)
    1950             :     {
    1951             :         /* Other system schemas don't get dumped */
    1952        2092 :         nsinfo->dobj.dump_contains = nsinfo->dobj.dump = DUMP_COMPONENT_NONE;
    1953             :     }
    1954         828 :     else if (strcmp(nsinfo->dobj.name, "public") == 0)
    1955             :     {
    1956             :         /*
    1957             :          * The public schema is a strange beast that sits in a sort of
    1958             :          * no-mans-land between being a system object and a user object.
    1959             :          * CREATE SCHEMA would fail, so its DUMP_COMPONENT_DEFINITION is just
    1960             :          * a comment and an indication of ownership.  If the owner is the
    1961             :          * default, omit that superfluous DUMP_COMPONENT_DEFINITION.  Before
    1962             :          * v15, the default owner was BOOTSTRAP_SUPERUSERID.
    1963             :          */
    1964         418 :         nsinfo->create = false;
    1965         418 :         nsinfo->dobj.dump = DUMP_COMPONENT_ALL;
    1966         418 :         if (nsinfo->nspowner == ROLE_PG_DATABASE_OWNER)
    1967         326 :             nsinfo->dobj.dump &= ~DUMP_COMPONENT_DEFINITION;
    1968         418 :         nsinfo->dobj.dump_contains = DUMP_COMPONENT_ALL;
    1969             : 
    1970             :         /*
    1971             :          * Also, make like it has a comment even if it doesn't; this is so
    1972             :          * that we'll emit a command to drop the comment, if appropriate.
    1973             :          * (Without this, we'd not call dumpCommentExtended for it.)
    1974             :          */
    1975         418 :         nsinfo->dobj.components |= DUMP_COMPONENT_COMMENT;
    1976             :     }
    1977             :     else
    1978         410 :         nsinfo->dobj.dump_contains = nsinfo->dobj.dump = DUMP_COMPONENT_ALL;
    1979             : 
    1980             :     /*
    1981             :      * In any case, a namespace can be excluded by an exclusion switch
    1982             :      */
    1983        5064 :     if (nsinfo->dobj.dump_contains &&
    1984        1276 :         simple_oid_list_member(&schema_exclude_oids,
    1985             :                                nsinfo->dobj.catId.oid))
    1986           6 :         nsinfo->dobj.dump_contains = nsinfo->dobj.dump = DUMP_COMPONENT_NONE;
    1987             : 
    1988             :     /*
    1989             :      * If the schema belongs to an extension, allow extension membership to
    1990             :      * override the dump decision for the schema itself.  However, this does
    1991             :      * not change dump_contains, so this won't change what we do with objects
    1992             :      * within the schema.  (If they belong to the extension, they'll get
    1993             :      * suppressed by it, otherwise not.)
    1994             :      */
    1995        3788 :     (void) checkExtensionMembership(&nsinfo->dobj, fout);
    1996        3788 : }
    1997             : 
    1998             : /*
    1999             :  * selectDumpableTable: policy-setting subroutine
    2000             :  *      Mark a table as to be dumped or not
    2001             :  */
    2002             : static void
    2003      122730 : selectDumpableTable(TableInfo *tbinfo, Archive *fout)
    2004             : {
    2005      122730 :     if (checkExtensionMembership(&tbinfo->dobj, fout))
    2006         450 :         return;                 /* extension membership overrides all else */
    2007             : 
    2008             :     /*
    2009             :      * If specific tables are being dumped, dump just those tables; else, dump
    2010             :      * according to the parent namespace's dump flag.
    2011             :      */
    2012      122280 :     if (table_include_oids.head != NULL)
    2013       10228 :         tbinfo->dobj.dump = simple_oid_list_member(&table_include_oids,
    2014             :                                                    tbinfo->dobj.catId.oid) ?
    2015        5114 :             DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2016             :     else
    2017      117166 :         tbinfo->dobj.dump = tbinfo->dobj.namespace->dobj.dump_contains;
    2018             : 
    2019             :     /*
    2020             :      * In any case, a table can be excluded by an exclusion switch
    2021             :      */
    2022      202552 :     if (tbinfo->dobj.dump &&
    2023       80272 :         simple_oid_list_member(&table_exclude_oids,
    2024             :                                tbinfo->dobj.catId.oid))
    2025          24 :         tbinfo->dobj.dump = DUMP_COMPONENT_NONE;
    2026             : }
    2027             : 
    2028             : /*
    2029             :  * selectDumpableType: policy-setting subroutine
    2030             :  *      Mark a type as to be dumped or not
    2031             :  *
    2032             :  * If it's a table's rowtype or an autogenerated array type, we also apply a
    2033             :  * special type code to facilitate sorting into the desired order.  (We don't
    2034             :  * want to consider those to be ordinary types because that would bring tables
    2035             :  * up into the datatype part of the dump order.)  We still set the object's
    2036             :  * dump flag; that's not going to cause the dummy type to be dumped, but we
    2037             :  * need it so that casts involving such types will be dumped correctly -- see
    2038             :  * dumpCast.  This means the flag should be set the same as for the underlying
    2039             :  * object (the table or base type).
    2040             :  */
    2041             : static void
    2042      336678 : selectDumpableType(TypeInfo *tyinfo, Archive *fout)
    2043             : {
    2044             :     /* skip complex types, except for standalone composite types */
    2045      336678 :     if (OidIsValid(tyinfo->typrelid) &&
    2046      121040 :         tyinfo->typrelkind != RELKIND_COMPOSITE_TYPE)
    2047             :     {
    2048      120572 :         TableInfo  *tytable = findTableByOid(tyinfo->typrelid);
    2049             : 
    2050      120572 :         tyinfo->dobj.objType = DO_DUMMY_TYPE;
    2051      120572 :         if (tytable != NULL)
    2052      120572 :             tyinfo->dobj.dump = tytable->dobj.dump;
    2053             :         else
    2054           0 :             tyinfo->dobj.dump = DUMP_COMPONENT_NONE;
    2055      120572 :         return;
    2056             :     }
    2057             : 
    2058             :     /* skip auto-generated array and multirange types */
    2059      216106 :     if (tyinfo->isArray || tyinfo->isMultirange)
    2060             :     {
    2061      164618 :         tyinfo->dobj.objType = DO_DUMMY_TYPE;
    2062             : 
    2063             :         /*
    2064             :          * Fall through to set the dump flag; we assume that the subsequent
    2065             :          * rules will do the same thing as they would for the array's base
    2066             :          * type or multirange's range type.  (We cannot reliably look up the
    2067             :          * base type here, since getTypes may not have processed it yet.)
    2068             :          */
    2069             :     }
    2070             : 
    2071      216106 :     if (checkExtensionMembership(&tyinfo->dobj, fout))
    2072         300 :         return;                 /* extension membership overrides all else */
    2073             : 
    2074             :     /* Dump based on if the contents of the namespace are being dumped */
    2075      215806 :     tyinfo->dobj.dump = tyinfo->dobj.namespace->dobj.dump_contains;
    2076             : }
    2077             : 
    2078             : /*
    2079             :  * selectDumpableDefaultACL: policy-setting subroutine
    2080             :  *      Mark a default ACL as to be dumped or not
    2081             :  *
    2082             :  * For per-schema default ACLs, dump if the schema is to be dumped.
    2083             :  * Otherwise dump if we are dumping "everything".  Note that dumpSchema
    2084             :  * and aclsSkip are checked separately.
    2085             :  */
    2086             : static void
    2087         392 : selectDumpableDefaultACL(DefaultACLInfo *dinfo, DumpOptions *dopt)
    2088             : {
    2089             :     /* Default ACLs can't be extension members */
    2090             : 
    2091         392 :     if (dinfo->dobj.namespace)
    2092             :         /* default ACLs are considered part of the namespace */
    2093         196 :         dinfo->dobj.dump = dinfo->dobj.namespace->dobj.dump_contains;
    2094             :     else
    2095         196 :         dinfo->dobj.dump = dopt->include_everything ?
    2096         196 :             DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2097         392 : }
    2098             : 
    2099             : /*
    2100             :  * selectDumpableCast: policy-setting subroutine
    2101             :  *      Mark a cast as to be dumped or not
    2102             :  *
    2103             :  * Casts do not belong to any particular namespace (since they haven't got
    2104             :  * names), nor do they have identifiable owners.  To distinguish user-defined
    2105             :  * casts from built-in ones, we must resort to checking whether the cast's
    2106             :  * OID is in the range reserved for initdb.
    2107             :  */
    2108             : static void
    2109      107390 : selectDumpableCast(CastInfo *cast, Archive *fout)
    2110             : {
    2111      107390 :     if (checkExtensionMembership(&cast->dobj, fout))
    2112           0 :         return;                 /* extension membership overrides all else */
    2113             : 
    2114             :     /*
    2115             :      * This would be DUMP_COMPONENT_ACL for from-initdb casts, but they do not
    2116             :      * support ACLs currently.
    2117             :      */
    2118      107390 :     if (cast->dobj.catId.oid <= (Oid) g_last_builtin_oid)
    2119      107172 :         cast->dobj.dump = DUMP_COMPONENT_NONE;
    2120             :     else
    2121         218 :         cast->dobj.dump = fout->dopt->include_everything ?
    2122         218 :             DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2123             : }
    2124             : 
    2125             : /*
    2126             :  * selectDumpableProcLang: policy-setting subroutine
    2127             :  *      Mark a procedural language as to be dumped or not
    2128             :  *
    2129             :  * Procedural languages do not belong to any particular namespace.  To
    2130             :  * identify built-in languages, we must resort to checking whether the
    2131             :  * language's OID is in the range reserved for initdb.
    2132             :  */
    2133             : static void
    2134         566 : selectDumpableProcLang(ProcLangInfo *plang, Archive *fout)
    2135             : {
    2136         566 :     if (checkExtensionMembership(&plang->dobj, fout))
    2137         468 :         return;                 /* extension membership overrides all else */
    2138             : 
    2139             :     /*
    2140             :      * Only include procedural languages when we are dumping everything.
    2141             :      *
    2142             :      * For from-initdb procedural languages, only include ACLs, as we do for
    2143             :      * the pg_catalog namespace.  We need this because procedural languages do
    2144             :      * not live in any namespace.
    2145             :      */
    2146          98 :     if (!fout->dopt->include_everything)
    2147          16 :         plang->dobj.dump = DUMP_COMPONENT_NONE;
    2148             :     else
    2149             :     {
    2150          82 :         if (plang->dobj.catId.oid <= (Oid) g_last_builtin_oid)
    2151           0 :             plang->dobj.dump = fout->remoteVersion < 90600 ?
    2152           0 :                 DUMP_COMPONENT_NONE : DUMP_COMPONENT_ACL;
    2153             :         else
    2154          82 :             plang->dobj.dump = DUMP_COMPONENT_ALL;
    2155             :     }
    2156             : }
    2157             : 
    2158             : /*
    2159             :  * selectDumpableAccessMethod: policy-setting subroutine
    2160             :  *      Mark an access method as to be dumped or not
    2161             :  *
    2162             :  * Access methods do not belong to any particular namespace.  To identify
    2163             :  * built-in access methods, we must resort to checking whether the
    2164             :  * method's OID is in the range reserved for initdb.
    2165             :  */
    2166             : static void
    2167        3542 : selectDumpableAccessMethod(AccessMethodInfo *method, Archive *fout)
    2168             : {
    2169        3542 :     if (checkExtensionMembership(&method->dobj, fout))
    2170          50 :         return;                 /* extension membership overrides all else */
    2171             : 
    2172             :     /*
    2173             :      * This would be DUMP_COMPONENT_ACL for from-initdb access methods, but
    2174             :      * they do not support ACLs currently.
    2175             :      */
    2176        3492 :     if (method->dobj.catId.oid <= (Oid) g_last_builtin_oid)
    2177        3276 :         method->dobj.dump = DUMP_COMPONENT_NONE;
    2178             :     else
    2179         216 :         method->dobj.dump = fout->dopt->include_everything ?
    2180         216 :             DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2181             : }
    2182             : 
    2183             : /*
    2184             :  * selectDumpableExtension: policy-setting subroutine
    2185             :  *      Mark an extension as to be dumped or not
    2186             :  *
    2187             :  * Built-in extensions should be skipped except for checking ACLs, since we
    2188             :  * assume those will already be installed in the target database.  We identify
    2189             :  * such extensions by their having OIDs in the range reserved for initdb.
    2190             :  * We dump all user-added extensions by default.  No extensions are dumped
    2191             :  * if include_everything is false (i.e., a --schema or --table switch was
    2192             :  * given), except if --extension specifies a list of extensions to dump.
    2193             :  */
    2194             : static void
    2195         520 : selectDumpableExtension(ExtensionInfo *extinfo, DumpOptions *dopt)
    2196             : {
    2197             :     /*
    2198             :      * Use DUMP_COMPONENT_ACL for built-in extensions, to allow users to
    2199             :      * change permissions on their member objects, if they wish to, and have
    2200             :      * those changes preserved.
    2201             :      */
    2202         520 :     if (extinfo->dobj.catId.oid <= (Oid) g_last_builtin_oid)
    2203         470 :         extinfo->dobj.dump = extinfo->dobj.dump_contains = DUMP_COMPONENT_ACL;
    2204             :     else
    2205             :     {
    2206             :         /* check if there is a list of extensions to dump */
    2207          50 :         if (extension_include_oids.head != NULL)
    2208           8 :             extinfo->dobj.dump = extinfo->dobj.dump_contains =
    2209           8 :                 simple_oid_list_member(&extension_include_oids,
    2210             :                                        extinfo->dobj.catId.oid) ?
    2211           8 :                 DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2212             :         else
    2213          42 :             extinfo->dobj.dump = extinfo->dobj.dump_contains =
    2214          42 :                 dopt->include_everything ?
    2215          42 :                 DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2216             : 
    2217             :         /* check that the extension is not explicitly excluded */
    2218          92 :         if (extinfo->dobj.dump &&
    2219          42 :             simple_oid_list_member(&extension_exclude_oids,
    2220             :                                    extinfo->dobj.catId.oid))
    2221           4 :             extinfo->dobj.dump = extinfo->dobj.dump_contains = DUMP_COMPONENT_NONE;
    2222             :     }
    2223         520 : }
    2224             : 
    2225             : /*
    2226             :  * selectDumpablePublicationObject: policy-setting subroutine
    2227             :  *      Mark a publication object as to be dumped or not
    2228             :  *
    2229             :  * A publication can have schemas and tables which have schemas, but those are
    2230             :  * ignored in decision making, because publications are only dumped when we are
    2231             :  * dumping everything.
    2232             :  */
    2233             : static void
    2234         882 : selectDumpablePublicationObject(DumpableObject *dobj, Archive *fout)
    2235             : {
    2236         882 :     if (checkExtensionMembership(dobj, fout))
    2237           0 :         return;                 /* extension membership overrides all else */
    2238             : 
    2239         882 :     dobj->dump = fout->dopt->include_everything ?
    2240         882 :         DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2241             : }
    2242             : 
    2243             : /*
    2244             :  * selectDumpableStatisticsObject: policy-setting subroutine
    2245             :  *      Mark an extended statistics object as to be dumped or not
    2246             :  *
    2247             :  * We dump an extended statistics object if the schema it's in and the table
    2248             :  * it's for are being dumped.  (This'll need more thought if statistics
    2249             :  * objects ever support cross-table stats.)
    2250             :  */
    2251             : static void
    2252         374 : selectDumpableStatisticsObject(StatsExtInfo *sobj, Archive *fout)
    2253             : {
    2254         374 :     if (checkExtensionMembership(&sobj->dobj, fout))
    2255           0 :         return;                 /* extension membership overrides all else */
    2256             : 
    2257         374 :     sobj->dobj.dump = sobj->dobj.namespace->dobj.dump_contains;
    2258         374 :     if (sobj->stattable == NULL ||
    2259         374 :         !(sobj->stattable->dobj.dump & DUMP_COMPONENT_DEFINITION))
    2260          56 :         sobj->dobj.dump = DUMP_COMPONENT_NONE;
    2261             : }
    2262             : 
    2263             : /*
    2264             :  * selectDumpableObject: policy-setting subroutine
    2265             :  *      Mark a generic dumpable object as to be dumped or not
    2266             :  *
    2267             :  * Use this only for object types without a special-case routine above.
    2268             :  */
    2269             : static void
    2270     1003806 : selectDumpableObject(DumpableObject *dobj, Archive *fout)
    2271             : {
    2272     1003806 :     if (checkExtensionMembership(dobj, fout))
    2273         336 :         return;                 /* extension membership overrides all else */
    2274             : 
    2275             :     /*
    2276             :      * Default policy is to dump if parent namespace is dumpable, or for
    2277             :      * non-namespace-associated items, dump if we're dumping "everything".
    2278             :      */
    2279     1003470 :     if (dobj->namespace)
    2280     1002132 :         dobj->dump = dobj->namespace->dobj.dump_contains;
    2281             :     else
    2282        1338 :         dobj->dump = fout->dopt->include_everything ?
    2283        1338 :             DUMP_COMPONENT_ALL : DUMP_COMPONENT_NONE;
    2284             : }
    2285             : 
    2286             : /*
    2287             :  *  Dump a table's contents for loading using the COPY command
    2288             :  *  - this routine is called by the Archiver when it wants the table
    2289             :  *    to be dumped.
    2290             :  */
    2291             : static int
    2292       11716 : dumpTableData_copy(Archive *fout, const void *dcontext)
    2293             : {
    2294       11716 :     TableDataInfo *tdinfo = (TableDataInfo *) dcontext;
    2295       11716 :     TableInfo  *tbinfo = tdinfo->tdtable;
    2296       11716 :     const char *classname = tbinfo->dobj.name;
    2297       11716 :     PQExpBuffer q = createPQExpBuffer();
    2298             : 
    2299             :     /*
    2300             :      * Note: can't use getThreadLocalPQExpBuffer() here, we're calling fmtId
    2301             :      * which uses it already.
    2302             :      */
    2303       11716 :     PQExpBuffer clistBuf = createPQExpBuffer();
    2304       11716 :     PGconn     *conn = GetConnection(fout);
    2305             :     PGresult   *res;
    2306             :     int         ret;
    2307             :     char       *copybuf;
    2308             :     const char *column_list;
    2309             : 
    2310       11716 :     pg_log_info("dumping contents of table \"%s.%s\"",
    2311             :                 tbinfo->dobj.namespace->dobj.name, classname);
    2312             : 
    2313             :     /*
    2314             :      * Specify the column list explicitly so that we have no possibility of
    2315             :      * retrieving data in the wrong column order.  (The default column
    2316             :      * ordering of COPY will not be what we want in certain corner cases
    2317             :      * involving ADD COLUMN and inheritance.)
    2318             :      */
    2319       11716 :     column_list = fmtCopyColumnList(tbinfo, clistBuf);
    2320             : 
    2321             :     /*
    2322             :      * Use COPY (SELECT ...) TO when dumping a foreign table's data, and when
    2323             :      * a filter condition was specified.  For other cases a simple COPY
    2324             :      * suffices.
    2325             :      */
    2326       11716 :     if (tdinfo->filtercond || tbinfo->relkind == RELKIND_FOREIGN_TABLE)
    2327             :     {
    2328             :         /* Temporary allows to access to foreign tables to dump data */
    2329           2 :         if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
    2330           2 :             set_restrict_relation_kind(fout, "view");
    2331             : 
    2332           2 :         appendPQExpBufferStr(q, "COPY (SELECT ");
    2333             :         /* klugery to get rid of parens in column list */
    2334           2 :         if (strlen(column_list) > 2)
    2335             :         {
    2336           2 :             appendPQExpBufferStr(q, column_list + 1);
    2337           2 :             q->data[q->len - 1] = ' ';
    2338             :         }
    2339             :         else
    2340           0 :             appendPQExpBufferStr(q, "* ");
    2341             : 
    2342           4 :         appendPQExpBuffer(q, "FROM %s %s) TO stdout;",
    2343           2 :                           fmtQualifiedDumpable(tbinfo),
    2344           2 :                           tdinfo->filtercond ? tdinfo->filtercond : "");
    2345             :     }
    2346             :     else
    2347             :     {
    2348       11714 :         appendPQExpBuffer(q, "COPY %s %s TO stdout;",
    2349       11714 :                           fmtQualifiedDumpable(tbinfo),
    2350             :                           column_list);
    2351             :     }
    2352       11716 :     res = ExecuteSqlQuery(fout, q->data, PGRES_COPY_OUT);
    2353       11714 :     PQclear(res);
    2354       11714 :     destroyPQExpBuffer(clistBuf);
    2355             : 
    2356             :     for (;;)
    2357             :     {
    2358     6133830 :         ret = PQgetCopyData(conn, &copybuf, 0);
    2359             : 
    2360     6133830 :         if (ret < 0)
    2361       11714 :             break;              /* done or error */
    2362             : 
    2363     6122116 :         if (copybuf)
    2364             :         {
    2365     6122116 :             WriteData(fout, copybuf, ret);
    2366     6122116 :             PQfreemem(copybuf);
    2367             :         }
    2368             : 
    2369             :         /* ----------
    2370             :          * THROTTLE:
    2371             :          *
    2372             :          * There was considerable discussion in late July, 2000 regarding
    2373             :          * slowing down pg_dump when backing up large tables. Users with both
    2374             :          * slow & fast (multi-processor) machines experienced performance
    2375             :          * degradation when doing a backup.
    2376             :          *
    2377             :          * Initial attempts based on sleeping for a number of ms for each ms
    2378             :          * of work were deemed too complex, then a simple 'sleep in each loop'
    2379             :          * implementation was suggested. The latter failed because the loop
    2380             :          * was too tight. Finally, the following was implemented:
    2381             :          *
    2382             :          * If throttle is non-zero, then
    2383             :          *      See how long since the last sleep.
    2384             :          *      Work out how long to sleep (based on ratio).
    2385             :          *      If sleep is more than 100ms, then
    2386             :          *          sleep
    2387             :          *          reset timer
    2388             :          *      EndIf
    2389             :          * EndIf
    2390             :          *
    2391             :          * where the throttle value was the number of ms to sleep per ms of
    2392             :          * work. The calculation was done in each loop.
    2393             :          *
    2394             :          * Most of the hard work is done in the backend, and this solution
    2395             :          * still did not work particularly well: on slow machines, the ratio
    2396             :          * was 50:1, and on medium paced machines, 1:1, and on fast
    2397             :          * multi-processor machines, it had little or no effect, for reasons
    2398             :          * that were unclear.
    2399             :          *
    2400             :          * Further discussion ensued, and the proposal was dropped.
    2401             :          *
    2402             :          * For those people who want this feature, it can be implemented using
    2403             :          * gettimeofday in each loop, calculating the time since last sleep,
    2404             :          * multiplying that by the sleep ratio, then if the result is more
    2405             :          * than a preset 'minimum sleep time' (say 100ms), call the 'select'
    2406             :          * function to sleep for a subsecond period ie.
    2407             :          *
    2408             :          * select(0, NULL, NULL, NULL, &tvi);
    2409             :          *
    2410             :          * This will return after the interval specified in the structure tvi.
    2411             :          * Finally, call gettimeofday again to save the 'last sleep time'.
    2412             :          * ----------
    2413             :          */
    2414             :     }
    2415       11714 :     archprintf(fout, "\\.\n\n\n");
    2416             : 
    2417       11714 :     if (ret == -2)
    2418             :     {
    2419             :         /* copy data transfer failed */
    2420           0 :         pg_log_error("Dumping the contents of table \"%s\" failed: PQgetCopyData() failed.", classname);
    2421           0 :         pg_log_error_detail("Error message from server: %s", PQerrorMessage(conn));
    2422           0 :         pg_log_error_detail("Command was: %s", q->data);
    2423           0 :         exit_nicely(1);
    2424             :     }
    2425             : 
    2426             :     /* Check command status and return to normal libpq state */
    2427       11714 :     res = PQgetResult(conn);
    2428       11714 :     if (PQresultStatus(res) != PGRES_COMMAND_OK)
    2429             :     {
    2430           0 :         pg_log_error("Dumping the contents of table \"%s\" failed: PQgetResult() failed.", classname);
    2431           0 :         pg_log_error_detail("Error message from server: %s", PQerrorMessage(conn));
    2432           0 :         pg_log_error_detail("Command was: %s", q->data);
    2433           0 :         exit_nicely(1);
    2434             :     }
    2435       11714 :     PQclear(res);
    2436             : 
    2437             :     /* Do this to ensure we've pumped libpq back to idle state */
    2438       11714 :     if (PQgetResult(conn) != NULL)
    2439           0 :         pg_log_warning("unexpected extra results during COPY of table \"%s\"",
    2440             :                        classname);
    2441             : 
    2442       11714 :     destroyPQExpBuffer(q);
    2443             : 
    2444             :     /* Revert back the setting */
    2445       11714 :     if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
    2446           0 :         set_restrict_relation_kind(fout, "view, foreign-table");
    2447             : 
    2448       11714 :     return 1;
    2449             : }
    2450             : 
    2451             : /*
    2452             :  * Dump table data using INSERT commands.
    2453             :  *
    2454             :  * Caution: when we restore from an archive file direct to database, the
    2455             :  * INSERT commands emitted by this function have to be parsed by
    2456             :  * pg_backup_db.c's ExecuteSimpleCommands(), which will not handle comments,
    2457             :  * E'' strings, or dollar-quoted strings.  So don't emit anything like that.
    2458             :  */
    2459             : static int
    2460         146 : dumpTableData_insert(Archive *fout, const void *dcontext)
    2461             : {
    2462         146 :     TableDataInfo *tdinfo = (TableDataInfo *) dcontext;
    2463         146 :     TableInfo  *tbinfo = tdinfo->tdtable;
    2464         146 :     DumpOptions *dopt = fout->dopt;
    2465         146 :     PQExpBuffer q = createPQExpBuffer();
    2466         146 :     PQExpBuffer insertStmt = NULL;
    2467             :     char       *attgenerated;
    2468             :     PGresult   *res;
    2469             :     int         nfields,
    2470             :                 i;
    2471         146 :     int         rows_per_statement = dopt->dump_inserts;
    2472         146 :     int         rows_this_statement = 0;
    2473             : 
    2474             :     /* Temporary allows to access to foreign tables to dump data */
    2475         146 :     if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
    2476           0 :         set_restrict_relation_kind(fout, "view");
    2477             : 
    2478             :     /*
    2479             :      * If we're going to emit INSERTs with column names, the most efficient
    2480             :      * way to deal with generated columns is to exclude them entirely.  For
    2481             :      * INSERTs without column names, we have to emit DEFAULT rather than the
    2482             :      * actual column value --- but we can save a few cycles by fetching nulls
    2483             :      * rather than the uninteresting-to-us value.
    2484             :      */
    2485         146 :     attgenerated = (char *) pg_malloc(tbinfo->numatts * sizeof(char));
    2486         146 :     appendPQExpBufferStr(q, "DECLARE _pg_dump_cursor CURSOR FOR SELECT ");
    2487         146 :     nfields = 0;
    2488         474 :     for (i = 0; i < tbinfo->numatts; i++)
    2489             :     {
    2490         328 :         if (tbinfo->attisdropped[i])
    2491           4 :             continue;
    2492         324 :         if (tbinfo->attgenerated[i] && dopt->column_inserts)
    2493          16 :             continue;
    2494         308 :         if (nfields > 0)
    2495         176 :             appendPQExpBufferStr(q, ", ");
    2496         308 :         if (tbinfo->attgenerated[i])
    2497          16 :             appendPQExpBufferStr(q, "NULL");
    2498             :         else
    2499         292 :             appendPQExpBufferStr(q, fmtId(tbinfo->attnames[i]));
    2500         308 :         attgenerated[nfields] = tbinfo->attgenerated[i];
    2501         308 :         nfields++;
    2502             :     }
    2503             :     /* Servers before 9.4 will complain about zero-column SELECT */
    2504         146 :     if (nfields == 0)
    2505          14 :         appendPQExpBufferStr(q, "NULL");
    2506         146 :     appendPQExpBuffer(q, " FROM ONLY %s",
    2507         146 :                       fmtQualifiedDumpable(tbinfo));
    2508         146 :     if (tdinfo->filtercond)
    2509           0 :         appendPQExpBuffer(q, " %s", tdinfo->filtercond);
    2510             : 
    2511         146 :     ExecuteSqlStatement(fout, q->data);
    2512             : 
    2513             :     while (1)
    2514             :     {
    2515         250 :         res = ExecuteSqlQuery(fout, "FETCH 100 FROM _pg_dump_cursor",
    2516             :                               PGRES_TUPLES_OK);
    2517             : 
    2518             :         /* cross-check field count, allowing for dummy NULL if any */
    2519         250 :         if (nfields != PQnfields(res) &&
    2520          20 :             !(nfields == 0 && PQnfields(res) == 1))
    2521           0 :             pg_fatal("wrong number of fields retrieved from table \"%s\"",
    2522             :                      tbinfo->dobj.name);
    2523             : 
    2524             :         /*
    2525             :          * First time through, we build as much of the INSERT statement as
    2526             :          * possible in "insertStmt", which we can then just print for each
    2527             :          * statement. If the table happens to have zero dumpable columns then
    2528             :          * this will be a complete statement, otherwise it will end in
    2529             :          * "VALUES" and be ready to have the row's column values printed.
    2530             :          */
    2531         250 :         if (insertStmt == NULL)
    2532             :         {
    2533             :             TableInfo  *targettab;
    2534             : 
    2535         146 :             insertStmt = createPQExpBuffer();
    2536             : 
    2537             :             /*
    2538             :              * When load-via-partition-root is set or forced, get the root
    2539             :              * table name for the partition table, so that we can reload data
    2540             :              * through the root table.
    2541             :              */
    2542         146 :             if (tbinfo->ispartition &&
    2543          80 :                 (dopt->load_via_partition_root ||
    2544          40 :                  forcePartitionRootLoad(tbinfo)))
    2545           6 :                 targettab = getRootTableInfo(tbinfo);
    2546             :             else
    2547         140 :                 targettab = tbinfo;
    2548             : 
    2549         146 :             appendPQExpBuffer(insertStmt, "INSERT INTO %s ",
    2550         146 :                               fmtQualifiedDumpable(targettab));
    2551             : 
    2552             :             /* corner case for zero-column table */
    2553         146 :             if (nfields == 0)
    2554             :             {
    2555          14 :                 appendPQExpBufferStr(insertStmt, "DEFAULT VALUES;\n");
    2556             :             }
    2557             :             else
    2558             :             {
    2559             :                 /* append the list of column names if required */
    2560         132 :                 if (dopt->column_inserts)
    2561             :                 {
    2562          58 :                     appendPQExpBufferChar(insertStmt, '(');
    2563         186 :                     for (int field = 0; field < nfields; field++)
    2564             :                     {
    2565         128 :                         if (field > 0)
    2566          70 :                             appendPQExpBufferStr(insertStmt, ", ");
    2567         128 :                         appendPQExpBufferStr(insertStmt,
    2568         128 :                                              fmtId(PQfname(res, field)));
    2569             :                     }
    2570          58 :                     appendPQExpBufferStr(insertStmt, ") ");
    2571             :                 }
    2572             : 
    2573         132 :                 if (tbinfo->needs_override)
    2574           4 :                     appendPQExpBufferStr(insertStmt, "OVERRIDING SYSTEM VALUE ");
    2575             : 
    2576         132 :                 appendPQExpBufferStr(insertStmt, "VALUES");
    2577             :             }
    2578             :         }
    2579             : 
    2580        6792 :         for (int tuple = 0; tuple < PQntuples(res); tuple++)
    2581             :         {
    2582             :             /* Write the INSERT if not in the middle of a multi-row INSERT. */
    2583        6542 :             if (rows_this_statement == 0)
    2584        6530 :                 archputs(insertStmt->data, fout);
    2585             : 
    2586             :             /*
    2587             :              * If it is zero-column table then we've already written the
    2588             :              * complete statement, which will mean we've disobeyed
    2589             :              * --rows-per-insert when it's set greater than 1.  We do support
    2590             :              * a way to make this multi-row with: SELECT UNION ALL SELECT
    2591             :              * UNION ALL ... but that's non-standard so we should avoid it
    2592             :              * given that using INSERTs is mostly only ever needed for
    2593             :              * cross-database exports.
    2594             :              */
    2595        6542 :             if (nfields == 0)
    2596          12 :                 continue;
    2597             : 
    2598             :             /* Emit a row heading */
    2599        6530 :             if (rows_per_statement == 1)
    2600        6512 :                 archputs(" (", fout);
    2601          18 :             else if (rows_this_statement > 0)
    2602          12 :                 archputs(",\n\t(", fout);
    2603             :             else
    2604           6 :                 archputs("\n\t(", fout);
    2605             : 
    2606       19698 :             for (int field = 0; field < nfields; field++)
    2607             :             {
    2608       13168 :                 if (field > 0)
    2609        6638 :                     archputs(", ", fout);
    2610       13168 :                 if (attgenerated[field])
    2611             :                 {
    2612           4 :                     archputs("DEFAULT", fout);
    2613           4 :                     continue;
    2614             :                 }
    2615       13164 :                 if (PQgetisnull(res, tuple, field))
    2616             :                 {
    2617         166 :                     archputs("NULL", fout);
    2618         166 :                     continue;
    2619             :                 }
    2620             : 
    2621             :                 /* XXX This code is partially duplicated in ruleutils.c */
    2622       12998 :                 switch (PQftype(res, field))
    2623             :                 {
    2624        8938 :                     case INT2OID:
    2625             :                     case INT4OID:
    2626             :                     case INT8OID:
    2627             :                     case OIDOID:
    2628             :                     case FLOAT4OID:
    2629             :                     case FLOAT8OID:
    2630             :                     case NUMERICOID:
    2631             :                         {
    2632             :                             /*
    2633             :                              * These types are printed without quotes unless
    2634             :                              * they contain values that aren't accepted by the
    2635             :                              * scanner unquoted (e.g., 'NaN').  Note that
    2636             :                              * strtod() and friends might accept NaN, so we
    2637             :                              * can't use that to test.
    2638             :                              *
    2639             :                              * In reality we only need to defend against
    2640             :                              * infinity and NaN, so we need not get too crazy
    2641             :                              * about pattern matching here.
    2642             :                              */
    2643        8938 :                             const char *s = PQgetvalue(res, tuple, field);
    2644             : 
    2645        8938 :                             if (strspn(s, "0123456789 +-eE.") == strlen(s))
    2646        8934 :                                 archputs(s, fout);
    2647             :                             else
    2648           4 :                                 archprintf(fout, "'%s'", s);
    2649             :                         }
    2650        8938 :                         break;
    2651             : 
    2652           4 :                     case BITOID:
    2653             :                     case VARBITOID:
    2654           4 :                         archprintf(fout, "B'%s'",
    2655             :                                    PQgetvalue(res, tuple, field));
    2656           4 :                         break;
    2657             : 
    2658           8 :                     case BOOLOID:
    2659           8 :                         if (strcmp(PQgetvalue(res, tuple, field), "t") == 0)
    2660           4 :                             archputs("true", fout);
    2661             :                         else
    2662           4 :                             archputs("false", fout);
    2663           8 :                         break;
    2664             : 
    2665        4048 :                     default:
    2666             :                         /* All other types are printed as string literals. */
    2667        4048 :                         resetPQExpBuffer(q);
    2668        4048 :                         appendStringLiteralAH(q,
    2669             :                                               PQgetvalue(res, tuple, field),
    2670             :                                               fout);
    2671        4048 :                         archputs(q->data, fout);
    2672        4048 :                         break;
    2673             :                 }
    2674             :             }
    2675             : 
    2676             :             /* Terminate the row ... */
    2677        6530 :             archputs(")", fout);
    2678             : 
    2679             :             /* ... and the statement, if the target no. of rows is reached */
    2680        6530 :             if (++rows_this_statement >= rows_per_statement)
    2681             :             {
    2682        6516 :                 if (dopt->do_nothing)
    2683           0 :                     archputs(" ON CONFLICT DO NOTHING;\n", fout);
    2684             :                 else
    2685        6516 :                     archputs(";\n", fout);
    2686             :                 /* Reset the row counter */
    2687        6516 :                 rows_this_statement = 0;
    2688             :             }
    2689             :         }
    2690             : 
    2691         250 :         if (PQntuples(res) <= 0)
    2692             :         {
    2693         146 :             PQclear(res);
    2694         146 :             break;
    2695             :         }
    2696         104 :         PQclear(res);
    2697             :     }
    2698             : 
    2699             :     /* Terminate any statements that didn't make the row count. */
    2700         146 :     if (rows_this_statement > 0)
    2701             :     {
    2702           2 :         if (dopt->do_nothing)
    2703           0 :             archputs(" ON CONFLICT DO NOTHING;\n", fout);
    2704             :         else
    2705           2 :             archputs(";\n", fout);
    2706             :     }
    2707             : 
    2708         146 :     archputs("\n\n", fout);
    2709             : 
    2710         146 :     ExecuteSqlStatement(fout, "CLOSE _pg_dump_cursor");
    2711             : 
    2712         146 :     destroyPQExpBuffer(q);
    2713         146 :     if (insertStmt != NULL)
    2714         146 :         destroyPQExpBuffer(insertStmt);
    2715         146 :     free(attgenerated);
    2716             : 
    2717             :     /* Revert back the setting */
    2718         146 :     if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
    2719           0 :         set_restrict_relation_kind(fout, "view, foreign-table");
    2720             : 
    2721         146 :     return 1;
    2722             : }
    2723             : 
    2724             : /*
    2725             :  * getRootTableInfo:
    2726             :  *     get the root TableInfo for the given partition table.
    2727             :  */
    2728             : static TableInfo *
    2729          18 : getRootTableInfo(const TableInfo *tbinfo)
    2730             : {
    2731             :     TableInfo  *parentTbinfo;
    2732             : 
    2733             :     Assert(tbinfo->ispartition);
    2734             :     Assert(tbinfo->numParents == 1);
    2735             : 
    2736          18 :     parentTbinfo = tbinfo->parents[0];
    2737          18 :     while (parentTbinfo->ispartition)
    2738             :     {
    2739             :         Assert(parentTbinfo->numParents == 1);
    2740           0 :         parentTbinfo = parentTbinfo->parents[0];
    2741             :     }
    2742             : 
    2743          18 :     return parentTbinfo;
    2744             : }
    2745             : 
    2746             : /*
    2747             :  * forcePartitionRootLoad
    2748             :  *     Check if we must force load_via_partition_root for this partition.
    2749             :  *
    2750             :  * This is required if any level of ancestral partitioned table has an
    2751             :  * unsafe partitioning scheme.
    2752             :  */
    2753             : static bool
    2754        3060 : forcePartitionRootLoad(const TableInfo *tbinfo)
    2755             : {
    2756             :     TableInfo  *parentTbinfo;
    2757             : 
    2758             :     Assert(tbinfo->ispartition);
    2759             :     Assert(tbinfo->numParents == 1);
    2760             : 
    2761        3060 :     parentTbinfo = tbinfo->parents[0];
    2762        3060 :     if (parentTbinfo->unsafe_partitions)
    2763          18 :         return true;
    2764        3798 :     while (parentTbinfo->ispartition)
    2765             :     {
    2766             :         Assert(parentTbinfo->numParents == 1);
    2767         756 :         parentTbinfo = parentTbinfo->parents[0];
    2768         756 :         if (parentTbinfo->unsafe_partitions)
    2769           0 :             return true;
    2770             :     }
    2771             : 
    2772        3042 :     return false;
    2773             : }
    2774             : 
    2775             : /*
    2776             :  * dumpTableData -
    2777             :  *    dump the contents of a single table
    2778             :  *
    2779             :  * Actually, this just makes an ArchiveEntry for the table contents.
    2780             :  */
    2781             : static void
    2782       12006 : dumpTableData(Archive *fout, const TableDataInfo *tdinfo)
    2783             : {
    2784       12006 :     DumpOptions *dopt = fout->dopt;
    2785       12006 :     TableInfo  *tbinfo = tdinfo->tdtable;
    2786       12006 :     PQExpBuffer copyBuf = createPQExpBuffer();
    2787       12006 :     PQExpBuffer clistBuf = createPQExpBuffer();
    2788             :     DataDumperPtr dumpFn;
    2789       12006 :     char       *tdDefn = NULL;
    2790             :     char       *copyStmt;
    2791             :     const char *copyFrom;
    2792             : 
    2793             :     /* We had better have loaded per-column details about this table */
    2794             :     Assert(tbinfo->interesting);
    2795             : 
    2796             :     /*
    2797             :      * When load-via-partition-root is set or forced, get the root table name
    2798             :      * for the partition table, so that we can reload data through the root
    2799             :      * table.  Then construct a comment to be inserted into the TOC entry's
    2800             :      * defn field, so that such cases can be identified reliably.
    2801             :      */
    2802       12006 :     if (tbinfo->ispartition &&
    2803        6040 :         (dopt->load_via_partition_root ||
    2804        3020 :          forcePartitionRootLoad(tbinfo)))
    2805          12 :     {
    2806             :         TableInfo  *parentTbinfo;
    2807             : 
    2808          12 :         parentTbinfo = getRootTableInfo(tbinfo);
    2809          12 :         copyFrom = fmtQualifiedDumpable(parentTbinfo);
    2810          12 :         printfPQExpBuffer(copyBuf, "-- load via partition root %s",
    2811             :                           copyFrom);
    2812          12 :         tdDefn = pg_strdup(copyBuf->data);
    2813             :     }
    2814             :     else
    2815       11994 :         copyFrom = fmtQualifiedDumpable(tbinfo);
    2816             : 
    2817       12006 :     if (dopt->dump_inserts == 0)
    2818             :     {
    2819             :         /* Dump/restore using COPY */
    2820       11860 :         dumpFn = dumpTableData_copy;
    2821             :         /* must use 2 steps here 'cause fmtId is nonreentrant */
    2822       11860 :         printfPQExpBuffer(copyBuf, "COPY %s ",
    2823             :                           copyFrom);
    2824       11860 :         appendPQExpBuffer(copyBuf, "%s FROM stdin;\n",
    2825             :                           fmtCopyColumnList(tbinfo, clistBuf));
    2826       11860 :         copyStmt = copyBuf->data;
    2827             :     }
    2828             :     else
    2829             :     {
    2830             :         /* Restore using INSERT */
    2831         146 :         dumpFn = dumpTableData_insert;
    2832         146 :         copyStmt = NULL;
    2833             :     }
    2834             : 
    2835             :     /*
    2836             :      * Note: although the TableDataInfo is a full DumpableObject, we treat its
    2837             :      * dependency on its table as "special" and pass it to ArchiveEntry now.
    2838             :      * See comments for BuildArchiveDependencies.
    2839             :      */
    2840       12006 :     if (tdinfo->dobj.dump & DUMP_COMPONENT_DATA)
    2841             :     {
    2842             :         TocEntry   *te;
    2843             : 
    2844       12006 :         te = ArchiveEntry(fout, tdinfo->dobj.catId, tdinfo->dobj.dumpId,
    2845       12006 :                           ARCHIVE_OPTS(.tag = tbinfo->dobj.name,
    2846             :                                        .namespace = tbinfo->dobj.namespace->dobj.name,
    2847             :                                        .owner = tbinfo->rolname,
    2848             :                                        .description = "TABLE DATA",
    2849             :                                        .section = SECTION_DATA,
    2850             :                                        .createStmt = tdDefn,
    2851             :                                        .copyStmt = copyStmt,
    2852             :                                        .deps = &(tbinfo->dobj.dumpId),
    2853             :                                        .nDeps = 1,
    2854             :                                        .dumpFn = dumpFn,
    2855             :                                        .dumpArg = tdinfo));
    2856             : 
    2857             :         /*
    2858             :          * Set the TocEntry's dataLength in case we are doing a parallel dump
    2859             :          * and want to order dump jobs by table size.  We choose to measure
    2860             :          * dataLength in table pages (including TOAST pages) during dump, so
    2861             :          * no scaling is needed.
    2862             :          *
    2863             :          * However, relpages is declared as "integer" in pg_class, and hence
    2864             :          * also in TableInfo, but it's really BlockNumber a/k/a unsigned int.
    2865             :          * Cast so that we get the right interpretation of table sizes
    2866             :          * exceeding INT_MAX pages.
    2867             :          */
    2868       12006 :         te->dataLength = (BlockNumber) tbinfo->relpages;
    2869       12006 :         te->dataLength += (BlockNumber) tbinfo->toastpages;
    2870             : 
    2871             :         /*
    2872             :          * If pgoff_t is only 32 bits wide, the above refinement is useless,
    2873             :          * and instead we'd better worry about integer overflow.  Clamp to
    2874             :          * INT_MAX if the correct result exceeds that.
    2875             :          */
    2876             :         if (sizeof(te->dataLength) == 4 &&
    2877             :             (tbinfo->relpages < 0 || tbinfo->toastpages < 0 ||
    2878             :              te->dataLength < 0))
    2879             :             te->dataLength = INT_MAX;
    2880             :     }
    2881             : 
    2882       12006 :     destroyPQExpBuffer(copyBuf);
    2883       12006 :     destroyPQExpBuffer(clistBuf);
    2884       12006 : }
    2885             : 
    2886             : /*
    2887             :  * refreshMatViewData -
    2888             :  *    load or refresh the contents of a single materialized view
    2889             :  *
    2890             :  * Actually, this just makes an ArchiveEntry for the REFRESH MATERIALIZED VIEW
    2891             :  * statement.
    2892             :  */
    2893             : static void
    2894         852 : refreshMatViewData(Archive *fout, const TableDataInfo *tdinfo)
    2895             : {
    2896         852 :     TableInfo  *tbinfo = tdinfo->tdtable;
    2897             :     PQExpBuffer q;
    2898             : 
    2899             :     /* If the materialized view is not flagged as populated, skip this. */
    2900         852 :     if (!tbinfo->relispopulated)
    2901         148 :         return;
    2902             : 
    2903         704 :     q = createPQExpBuffer();
    2904             : 
    2905         704 :     appendPQExpBuffer(q, "REFRESH MATERIALIZED VIEW %s;\n",
    2906         704 :                       fmtQualifiedDumpable(tbinfo));
    2907             : 
    2908         704 :     if (tdinfo->dobj.dump & DUMP_COMPONENT_DATA)
    2909         704 :         ArchiveEntry(fout,
    2910             :                      tdinfo->dobj.catId, /* catalog ID */
    2911             :                      tdinfo->dobj.dumpId,    /* dump ID */
    2912         704 :                      ARCHIVE_OPTS(.tag = tbinfo->dobj.name,
    2913             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
    2914             :                                   .owner = tbinfo->rolname,
    2915             :                                   .description = "MATERIALIZED VIEW DATA",
    2916             :                                   .section = SECTION_POST_DATA,
    2917             :                                   .createStmt = q->data,
    2918             :                                   .deps = tdinfo->dobj.dependencies,
    2919             :                                   .nDeps = tdinfo->dobj.nDeps));
    2920             : 
    2921         704 :     destroyPQExpBuffer(q);
    2922             : }
    2923             : 
    2924             : /*
    2925             :  * getTableData -
    2926             :  *    set up dumpable objects representing the contents of tables
    2927             :  */
    2928             : static void
    2929         452 : getTableData(DumpOptions *dopt, TableInfo *tblinfo, int numTables, char relkind)
    2930             : {
    2931             :     int         i;
    2932             : 
    2933      119278 :     for (i = 0; i < numTables; i++)
    2934             :     {
    2935      118826 :         if (tblinfo[i].dobj.dump & DUMP_COMPONENT_DATA &&
    2936        1796 :             (!relkind || tblinfo[i].relkind == relkind))
    2937       16752 :             makeTableDataInfo(dopt, &(tblinfo[i]));
    2938             :     }
    2939         452 : }
    2940             : 
    2941             : /*
    2942             :  * Make a dumpable object for the data of this specific table
    2943             :  *
    2944             :  * Note: we make a TableDataInfo if and only if we are going to dump the
    2945             :  * table data; the "dump" field in such objects isn't very interesting.
    2946             :  */
    2947             : static void
    2948       16830 : makeTableDataInfo(DumpOptions *dopt, TableInfo *tbinfo)
    2949             : {
    2950             :     TableDataInfo *tdinfo;
    2951             : 
    2952             :     /*
    2953             :      * Nothing to do if we already decided to dump the table.  This will
    2954             :      * happen for "config" tables.
    2955             :      */
    2956       16830 :     if (tbinfo->dataObj != NULL)
    2957           2 :         return;
    2958             : 
    2959             :     /* Skip VIEWs (no data to dump) */
    2960       16828 :     if (tbinfo->relkind == RELKIND_VIEW)
    2961        1254 :         return;
    2962             :     /* Skip FOREIGN TABLEs (no data to dump) unless requested explicitly */
    2963       15574 :     if (tbinfo->relkind == RELKIND_FOREIGN_TABLE &&
    2964          82 :         (foreign_servers_include_oids.head == NULL ||
    2965           8 :          !simple_oid_list_member(&foreign_servers_include_oids,
    2966             :                                  tbinfo->foreign_server)))
    2967          80 :         return;
    2968             :     /* Skip partitioned tables (data in partitions) */
    2969       15494 :     if (tbinfo->relkind == RELKIND_PARTITIONED_TABLE)
    2970        1448 :         return;
    2971             : 
    2972             :     /* Don't dump data in unlogged tables, if so requested */
    2973       14046 :     if (tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED &&
    2974         136 :         dopt->no_unlogged_table_data)
    2975          36 :         return;
    2976             : 
    2977             :     /* Check that the data is not explicitly excluded */
    2978       14010 :     if (simple_oid_list_member(&tabledata_exclude_oids,
    2979             :                                tbinfo->dobj.catId.oid))
    2980          16 :         return;
    2981             : 
    2982             :     /* OK, let's dump it */
    2983       13994 :     tdinfo = (TableDataInfo *) pg_malloc(sizeof(TableDataInfo));
    2984             : 
    2985       13994 :     if (tbinfo->relkind == RELKIND_MATVIEW)
    2986         852 :         tdinfo->dobj.objType = DO_REFRESH_MATVIEW;
    2987       13142 :     else if (tbinfo->relkind == RELKIND_SEQUENCE)
    2988        1136 :         tdinfo->dobj.objType = DO_SEQUENCE_SET;
    2989             :     else
    2990       12006 :         tdinfo->dobj.objType = DO_TABLE_DATA;
    2991             : 
    2992             :     /*
    2993             :      * Note: use tableoid 0 so that this object won't be mistaken for
    2994             :      * something that pg_depend entries apply to.
    2995             :      */
    2996       13994 :     tdinfo->dobj.catId.tableoid = 0;
    2997       13994 :     tdinfo->dobj.catId.oid = tbinfo->dobj.catId.oid;
    2998       13994 :     AssignDumpId(&tdinfo->dobj);
    2999       13994 :     tdinfo->dobj.name = tbinfo->dobj.name;
    3000       13994 :     tdinfo->dobj.namespace = tbinfo->dobj.namespace;
    3001       13994 :     tdinfo->tdtable = tbinfo;
    3002       13994 :     tdinfo->filtercond = NULL;   /* might get set later */
    3003       13994 :     addObjectDependency(&tdinfo->dobj, tbinfo->dobj.dumpId);
    3004             : 
    3005             :     /* A TableDataInfo contains data, of course */
    3006       13994 :     tdinfo->dobj.components |= DUMP_COMPONENT_DATA;
    3007             : 
    3008       13994 :     tbinfo->dataObj = tdinfo;
    3009             : 
    3010             :     /*
    3011             :      * Materialized view statistics must be restored after the data, because
    3012             :      * REFRESH MATERIALIZED VIEW replaces the storage and resets the stats.
    3013             :      *
    3014             :      * The dependency is added here because the statistics objects are created
    3015             :      * first.
    3016             :      */
    3017       13994 :     if (tbinfo->relkind == RELKIND_MATVIEW && tbinfo->stats != NULL)
    3018             :     {
    3019         740 :         tbinfo->stats->section = SECTION_POST_DATA;
    3020         740 :         addObjectDependency(&tbinfo->stats->dobj, tdinfo->dobj.dumpId);
    3021             :     }
    3022             : 
    3023             :     /* Make sure that we'll collect per-column info for this table. */
    3024       13994 :     tbinfo->interesting = true;
    3025             : }
    3026             : 
    3027             : /*
    3028             :  * The refresh for a materialized view must be dependent on the refresh for
    3029             :  * any materialized view that this one is dependent on.
    3030             :  *
    3031             :  * This must be called after all the objects are created, but before they are
    3032             :  * sorted.
    3033             :  */
    3034             : static void
    3035         396 : buildMatViewRefreshDependencies(Archive *fout)
    3036             : {
    3037             :     PQExpBuffer query;
    3038             :     PGresult   *res;
    3039             :     int         ntups,
    3040             :                 i;
    3041             :     int         i_classid,
    3042             :                 i_objid,
    3043             :                 i_refobjid;
    3044             : 
    3045             :     /* No Mat Views before 9.3. */
    3046         396 :     if (fout->remoteVersion < 90300)
    3047           0 :         return;
    3048             : 
    3049         396 :     query = createPQExpBuffer();
    3050             : 
    3051         396 :     appendPQExpBufferStr(query, "WITH RECURSIVE w AS "
    3052             :                          "( "
    3053             :                          "SELECT d1.objid, d2.refobjid, c2.relkind AS refrelkind "
    3054             :                          "FROM pg_depend d1 "
    3055             :                          "JOIN pg_class c1 ON c1.oid = d1.objid "
    3056             :                          "AND c1.relkind = " CppAsString2(RELKIND_MATVIEW)
    3057             :                          " JOIN pg_rewrite r1 ON r1.ev_class = d1.objid "
    3058             :                          "JOIN pg_depend d2 ON d2.classid = 'pg_rewrite'::regclass "
    3059             :                          "AND d2.objid = r1.oid "
    3060             :                          "AND d2.refobjid <> d1.objid "
    3061             :                          "JOIN pg_class c2 ON c2.oid = d2.refobjid "
    3062             :                          "AND c2.relkind IN (" CppAsString2(RELKIND_MATVIEW) ","
    3063             :                          CppAsString2(RELKIND_VIEW) ") "
    3064             :                          "WHERE d1.classid = 'pg_class'::regclass "
    3065             :                          "UNION "
    3066             :                          "SELECT w.objid, d3.refobjid, c3.relkind "
    3067             :                          "FROM w "
    3068             :                          "JOIN pg_rewrite r3 ON r3.ev_class = w.refobjid "
    3069             :                          "JOIN pg_depend d3 ON d3.classid = 'pg_rewrite'::regclass "
    3070             :                          "AND d3.objid = r3.oid "
    3071             :                          "AND d3.refobjid <> w.refobjid "
    3072             :                          "JOIN pg_class c3 ON c3.oid = d3.refobjid "
    3073             :                          "AND c3.relkind IN (" CppAsString2(RELKIND_MATVIEW) ","
    3074             :                          CppAsString2(RELKIND_VIEW) ") "
    3075             :                          ") "
    3076             :                          "SELECT 'pg_class'::regclass::oid AS classid, objid, refobjid "
    3077             :                          "FROM w "
    3078             :                          "WHERE refrelkind = " CppAsString2(RELKIND_MATVIEW));
    3079             : 
    3080         396 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    3081             : 
    3082         396 :     ntups = PQntuples(res);
    3083             : 
    3084         396 :     i_classid = PQfnumber(res, "classid");
    3085         396 :     i_objid = PQfnumber(res, "objid");
    3086         396 :     i_refobjid = PQfnumber(res, "refobjid");
    3087             : 
    3088         978 :     for (i = 0; i < ntups; i++)
    3089             :     {
    3090             :         CatalogId   objId;
    3091             :         CatalogId   refobjId;
    3092             :         DumpableObject *dobj;
    3093             :         DumpableObject *refdobj;
    3094             :         TableInfo  *tbinfo;
    3095             :         TableInfo  *reftbinfo;
    3096             : 
    3097         582 :         objId.tableoid = atooid(PQgetvalue(res, i, i_classid));
    3098         582 :         objId.oid = atooid(PQgetvalue(res, i, i_objid));
    3099         582 :         refobjId.tableoid = objId.tableoid;
    3100         582 :         refobjId.oid = atooid(PQgetvalue(res, i, i_refobjid));
    3101             : 
    3102         582 :         dobj = findObjectByCatalogId(objId);
    3103         582 :         if (dobj == NULL)
    3104          96 :             continue;
    3105             : 
    3106             :         Assert(dobj->objType == DO_TABLE);
    3107         582 :         tbinfo = (TableInfo *) dobj;
    3108             :         Assert(tbinfo->relkind == RELKIND_MATVIEW);
    3109         582 :         dobj = (DumpableObject *) tbinfo->dataObj;
    3110         582 :         if (dobj == NULL)
    3111          96 :             continue;
    3112             :         Assert(dobj->objType == DO_REFRESH_MATVIEW);
    3113             : 
    3114         486 :         refdobj = findObjectByCatalogId(refobjId);
    3115         486 :         if (refdobj == NULL)
    3116           0 :             continue;
    3117             : 
    3118             :         Assert(refdobj->objType == DO_TABLE);
    3119         486 :         reftbinfo = (TableInfo *) refdobj;
    3120             :         Assert(reftbinfo->relkind == RELKIND_MATVIEW);
    3121         486 :         refdobj = (DumpableObject *) reftbinfo->dataObj;
    3122         486 :         if (refdobj == NULL)
    3123           0 :             continue;
    3124             :         Assert(refdobj->objType == DO_REFRESH_MATVIEW);
    3125             : 
    3126         486 :         addObjectDependency(dobj, refdobj->dumpId);
    3127             : 
    3128         486 :         if (!reftbinfo->relispopulated)
    3129          74 :             tbinfo->relispopulated = false;
    3130             :     }
    3131             : 
    3132         396 :     PQclear(res);
    3133             : 
    3134         396 :     destroyPQExpBuffer(query);
    3135             : }
    3136             : 
    3137             : /*
    3138             :  * getTableDataFKConstraints -
    3139             :  *    add dump-order dependencies reflecting foreign key constraints
    3140             :  *
    3141             :  * This code is executed only in a data-only dump --- in schema+data dumps
    3142             :  * we handle foreign key issues by not creating the FK constraints until
    3143             :  * after the data is loaded.  In a data-only dump, however, we want to
    3144             :  * order the table data objects in such a way that a table's referenced
    3145             :  * tables are restored first.  (In the presence of circular references or
    3146             :  * self-references this may be impossible; we'll detect and complain about
    3147             :  * that during the dependency sorting step.)
    3148             :  */
    3149             : static void
    3150          14 : getTableDataFKConstraints(void)
    3151             : {
    3152             :     DumpableObject **dobjs;
    3153             :     int         numObjs;
    3154             :     int         i;
    3155             : 
    3156             :     /* Search through all the dumpable objects for FK constraints */
    3157          14 :     getDumpableObjects(&dobjs, &numObjs);
    3158       50728 :     for (i = 0; i < numObjs; i++)
    3159             :     {
    3160       50714 :         if (dobjs[i]->objType == DO_FK_CONSTRAINT)
    3161             :         {
    3162          16 :             ConstraintInfo *cinfo = (ConstraintInfo *) dobjs[i];
    3163             :             TableInfo  *ftable;
    3164             : 
    3165             :             /* Not interesting unless both tables are to be dumped */
    3166          16 :             if (cinfo->contable == NULL ||
    3167          16 :                 cinfo->contable->dataObj == NULL)
    3168           8 :                 continue;
    3169           8 :             ftable = findTableByOid(cinfo->confrelid);
    3170           8 :             if (ftable == NULL ||
    3171           8 :                 ftable->dataObj == NULL)
    3172           0 :                 continue;
    3173             : 
    3174             :             /*
    3175             :              * Okay, make referencing table's TABLE_DATA object depend on the
    3176             :              * referenced table's TABLE_DATA object.
    3177             :              */
    3178           8 :             addObjectDependency(&cinfo->contable->dataObj->dobj,
    3179           8 :                                 ftable->dataObj->dobj.dumpId);
    3180             :         }
    3181             :     }
    3182          14 :     free(dobjs);
    3183          14 : }
    3184             : 
    3185             : 
    3186             : /*
    3187             :  * dumpDatabase:
    3188             :  *  dump the database definition
    3189             :  */
    3190             : static void
    3191         264 : dumpDatabase(Archive *fout)
    3192             : {
    3193         264 :     DumpOptions *dopt = fout->dopt;
    3194         264 :     PQExpBuffer dbQry = createPQExpBuffer();
    3195         264 :     PQExpBuffer delQry = createPQExpBuffer();
    3196         264 :     PQExpBuffer creaQry = createPQExpBuffer();
    3197         264 :     PQExpBuffer labelq = createPQExpBuffer();
    3198         264 :     PGconn     *conn = GetConnection(fout);
    3199             :     PGresult   *res;
    3200             :     int         i_tableoid,
    3201             :                 i_oid,
    3202             :                 i_datname,
    3203             :                 i_datdba,
    3204             :                 i_encoding,
    3205             :                 i_datlocprovider,
    3206             :                 i_collate,
    3207             :                 i_ctype,
    3208             :                 i_datlocale,
    3209             :                 i_daticurules,
    3210             :                 i_frozenxid,
    3211             :                 i_minmxid,
    3212             :                 i_datacl,
    3213             :                 i_acldefault,
    3214             :                 i_datistemplate,
    3215             :                 i_datconnlimit,
    3216             :                 i_datcollversion,
    3217             :                 i_tablespace;
    3218             :     CatalogId   dbCatId;
    3219             :     DumpId      dbDumpId;
    3220             :     DumpableAcl dbdacl;
    3221             :     const char *datname,
    3222             :                *dba,
    3223             :                *encoding,
    3224             :                *datlocprovider,
    3225             :                *collate,
    3226             :                *ctype,
    3227             :                *locale,
    3228             :                *icurules,
    3229             :                *datistemplate,
    3230             :                *datconnlimit,
    3231             :                *tablespace;
    3232             :     uint32      frozenxid,
    3233             :                 minmxid;
    3234             :     char       *qdatname;
    3235             : 
    3236         264 :     pg_log_info("saving database definition");
    3237             : 
    3238             :     /*
    3239             :      * Fetch the database-level properties for this database.
    3240             :      */
    3241         264 :     appendPQExpBufferStr(dbQry, "SELECT tableoid, oid, datname, "
    3242             :                          "datdba, "
    3243             :                          "pg_encoding_to_char(encoding) AS encoding, "
    3244             :                          "datcollate, datctype, datfrozenxid, "
    3245             :                          "datacl, acldefault('d', datdba) AS acldefault, "
    3246             :                          "datistemplate, datconnlimit, ");
    3247         264 :     if (fout->remoteVersion >= 90300)
    3248         264 :         appendPQExpBufferStr(dbQry, "datminmxid, ");
    3249             :     else
    3250           0 :         appendPQExpBufferStr(dbQry, "0 AS datminmxid, ");
    3251         264 :     if (fout->remoteVersion >= 170000)
    3252         264 :         appendPQExpBufferStr(dbQry, "datlocprovider, datlocale, datcollversion, ");
    3253           0 :     else if (fout->remoteVersion >= 150000)
    3254           0 :         appendPQExpBufferStr(dbQry, "datlocprovider, daticulocale AS datlocale, datcollversion, ");
    3255             :     else
    3256           0 :         appendPQExpBufferStr(dbQry, "'c' AS datlocprovider, NULL AS datlocale, NULL AS datcollversion, ");
    3257         264 :     if (fout->remoteVersion >= 160000)
    3258         264 :         appendPQExpBufferStr(dbQry, "daticurules, ");
    3259             :     else
    3260           0 :         appendPQExpBufferStr(dbQry, "NULL AS daticurules, ");
    3261         264 :     appendPQExpBufferStr(dbQry,
    3262             :                          "(SELECT spcname FROM pg_tablespace t WHERE t.oid = dattablespace) AS tablespace, "
    3263             :                          "shobj_description(oid, 'pg_database') AS description "
    3264             :                          "FROM pg_database "
    3265             :                          "WHERE datname = current_database()");
    3266             : 
    3267         264 :     res = ExecuteSqlQueryForSingleRow(fout, dbQry->data);
    3268             : 
    3269         264 :     i_tableoid = PQfnumber(res, "tableoid");
    3270         264 :     i_oid = PQfnumber(res, "oid");
    3271         264 :     i_datname = PQfnumber(res, "datname");
    3272         264 :     i_datdba = PQfnumber(res, "datdba");
    3273         264 :     i_encoding = PQfnumber(res, "encoding");
    3274         264 :     i_datlocprovider = PQfnumber(res, "datlocprovider");
    3275         264 :     i_collate = PQfnumber(res, "datcollate");
    3276         264 :     i_ctype = PQfnumber(res, "datctype");
    3277         264 :     i_datlocale = PQfnumber(res, "datlocale");
    3278         264 :     i_daticurules = PQfnumber(res, "daticurules");
    3279         264 :     i_frozenxid = PQfnumber(res, "datfrozenxid");
    3280         264 :     i_minmxid = PQfnumber(res, "datminmxid");
    3281         264 :     i_datacl = PQfnumber(res, "datacl");
    3282         264 :     i_acldefault = PQfnumber(res, "acldefault");
    3283         264 :     i_datistemplate = PQfnumber(res, "datistemplate");
    3284         264 :     i_datconnlimit = PQfnumber(res, "datconnlimit");
    3285         264 :     i_datcollversion = PQfnumber(res, "datcollversion");
    3286         264 :     i_tablespace = PQfnumber(res, "tablespace");
    3287             : 
    3288         264 :     dbCatId.tableoid = atooid(PQgetvalue(res, 0, i_tableoid));
    3289         264 :     dbCatId.oid = atooid(PQgetvalue(res, 0, i_oid));
    3290         264 :     datname = PQgetvalue(res, 0, i_datname);
    3291         264 :     dba = getRoleName(PQgetvalue(res, 0, i_datdba));
    3292         264 :     encoding = PQgetvalue(res, 0, i_encoding);
    3293         264 :     datlocprovider = PQgetvalue(res, 0, i_datlocprovider);
    3294         264 :     collate = PQgetvalue(res, 0, i_collate);
    3295         264 :     ctype = PQgetvalue(res, 0, i_ctype);
    3296         264 :     if (!PQgetisnull(res, 0, i_datlocale))
    3297          30 :         locale = PQgetvalue(res, 0, i_datlocale);
    3298             :     else
    3299         234 :         locale = NULL;
    3300         264 :     if (!PQgetisnull(res, 0, i_daticurules))
    3301           0 :         icurules = PQgetvalue(res, 0, i_daticurules);
    3302             :     else
    3303         264 :         icurules = NULL;
    3304         264 :     frozenxid = atooid(PQgetvalue(res, 0, i_frozenxid));
    3305         264 :     minmxid = atooid(PQgetvalue(res, 0, i_minmxid));
    3306         264 :     dbdacl.acl = PQgetvalue(res, 0, i_datacl);
    3307         264 :     dbdacl.acldefault = PQgetvalue(res, 0, i_acldefault);
    3308         264 :     datistemplate = PQgetvalue(res, 0, i_datistemplate);
    3309         264 :     datconnlimit = PQgetvalue(res, 0, i_datconnlimit);
    3310         264 :     tablespace = PQgetvalue(res, 0, i_tablespace);
    3311             : 
    3312         264 :     qdatname = pg_strdup(fmtId(datname));
    3313             : 
    3314             :     /*
    3315             :      * Prepare the CREATE DATABASE command.  We must specify OID (if we want
    3316             :      * to preserve that), as well as the encoding, locale, and tablespace
    3317             :      * since those can't be altered later.  Other DB properties are left to
    3318             :      * the DATABASE PROPERTIES entry, so that they can be applied after
    3319             :      * reconnecting to the target DB.
    3320             :      *
    3321             :      * For binary upgrade, we use the FILE_COPY strategy because testing has
    3322             :      * shown it to be faster.  When the server is in binary upgrade mode, it
    3323             :      * will also skip the checkpoints this strategy ordinarily performs.
    3324             :      */
    3325         264 :     if (dopt->binary_upgrade)
    3326             :     {
    3327          60 :         appendPQExpBuffer(creaQry,
    3328             :                           "CREATE DATABASE %s WITH TEMPLATE = template0 "
    3329             :                           "OID = %u STRATEGY = FILE_COPY",
    3330             :                           qdatname, dbCatId.oid);
    3331             :     }
    3332             :     else
    3333             :     {
    3334         204 :         appendPQExpBuffer(creaQry, "CREATE DATABASE %s WITH TEMPLATE = template0",
    3335             :                           qdatname);
    3336             :     }
    3337         264 :     if (strlen(encoding) > 0)
    3338             :     {
    3339         264 :         appendPQExpBufferStr(creaQry, " ENCODING = ");
    3340         264 :         appendStringLiteralAH(creaQry, encoding, fout);
    3341             :     }
    3342             : 
    3343         264 :     appendPQExpBufferStr(creaQry, " LOCALE_PROVIDER = ");
    3344         264 :     if (datlocprovider[0] == 'b')
    3345          30 :         appendPQExpBufferStr(creaQry, "builtin");
    3346         234 :     else if (datlocprovider[0] == 'c')
    3347         234 :         appendPQExpBufferStr(creaQry, "libc");
    3348           0 :     else if (datlocprovider[0] == 'i')
    3349           0 :         appendPQExpBufferStr(creaQry, "icu");
    3350             :     else
    3351           0 :         pg_fatal("unrecognized locale provider: %s",
    3352             :                  datlocprovider);
    3353             : 
    3354         264 :     if (strlen(collate) > 0 && strcmp(collate, ctype) == 0)
    3355             :     {
    3356         264 :         appendPQExpBufferStr(creaQry, " LOCALE = ");
    3357         264 :         appendStringLiteralAH(creaQry, collate, fout);
    3358             :     }
    3359             :     else
    3360             :     {
    3361           0 :         if (strlen(collate) > 0)
    3362             :         {
    3363           0 :             appendPQExpBufferStr(creaQry, " LC_COLLATE = ");
    3364           0 :             appendStringLiteralAH(creaQry, collate, fout);
    3365             :         }
    3366           0 :         if (strlen(ctype) > 0)
    3367             :         {
    3368           0 :             appendPQExpBufferStr(creaQry, " LC_CTYPE = ");
    3369           0 :             appendStringLiteralAH(creaQry, ctype, fout);
    3370             :         }
    3371             :     }
    3372         264 :     if (locale)
    3373             :     {
    3374          30 :         if (datlocprovider[0] == 'b')
    3375          30 :             appendPQExpBufferStr(creaQry, " BUILTIN_LOCALE = ");
    3376             :         else
    3377           0 :             appendPQExpBufferStr(creaQry, " ICU_LOCALE = ");
    3378             : 
    3379          30 :         appendStringLiteralAH(creaQry, locale, fout);
    3380             :     }
    3381             : 
    3382         264 :     if (icurules)
    3383             :     {
    3384           0 :         appendPQExpBufferStr(creaQry, " ICU_RULES = ");
    3385           0 :         appendStringLiteralAH(creaQry, icurules, fout);
    3386             :     }
    3387             : 
    3388             :     /*
    3389             :      * For binary upgrade, carry over the collation version.  For normal
    3390             :      * dump/restore, omit the version, so that it is computed upon restore.
    3391             :      */
    3392         264 :     if (dopt->binary_upgrade)
    3393             :     {
    3394          60 :         if (!PQgetisnull(res, 0, i_datcollversion))
    3395             :         {
    3396          60 :             appendPQExpBufferStr(creaQry, " COLLATION_VERSION = ");
    3397          60 :             appendStringLiteralAH(creaQry,
    3398             :                                   PQgetvalue(res, 0, i_datcollversion),
    3399             :                                   fout);
    3400             :         }
    3401             :     }
    3402             : 
    3403             :     /*
    3404             :      * Note: looking at dopt->outputNoTablespaces here is completely the wrong
    3405             :      * thing; the decision whether to specify a tablespace should be left till
    3406             :      * pg_restore, so that pg_restore --no-tablespaces applies.  Ideally we'd
    3407             :      * label the DATABASE entry with the tablespace and let the normal
    3408             :      * tablespace selection logic work ... but CREATE DATABASE doesn't pay
    3409             :      * attention to default_tablespace, so that won't work.
    3410             :      */
    3411         264 :     if (strlen(tablespace) > 0 && strcmp(tablespace, "pg_default") != 0 &&
    3412           0 :         !dopt->outputNoTablespaces)
    3413           0 :         appendPQExpBuffer(creaQry, " TABLESPACE = %s",
    3414             :                           fmtId(tablespace));
    3415         264 :     appendPQExpBufferStr(creaQry, ";\n");
    3416             : 
    3417         264 :     appendPQExpBuffer(delQry, "DROP DATABASE %s;\n",
    3418             :                       qdatname);
    3419             : 
    3420         264 :     dbDumpId = createDumpId();
    3421             : 
    3422         264 :     ArchiveEntry(fout,
    3423             :                  dbCatId,       /* catalog ID */
    3424             :                  dbDumpId,      /* dump ID */
    3425         264 :                  ARCHIVE_OPTS(.tag = datname,
    3426             :                               .owner = dba,
    3427             :                               .description = "DATABASE",
    3428             :                               .section = SECTION_PRE_DATA,
    3429             :                               .createStmt = creaQry->data,
    3430             :                               .dropStmt = delQry->data));
    3431             : 
    3432             :     /* Compute correct tag for archive entry */
    3433         264 :     appendPQExpBuffer(labelq, "DATABASE %s", qdatname);
    3434             : 
    3435             :     /* Dump DB comment if any */
    3436             :     {
    3437             :         /*
    3438             :          * 8.2 and up keep comments on shared objects in a shared table, so we
    3439             :          * cannot use the dumpComment() code used for other database objects.
    3440             :          * Be careful that the ArchiveEntry parameters match that function.
    3441             :          */
    3442         264 :         char       *comment = PQgetvalue(res, 0, PQfnumber(res, "description"));
    3443             : 
    3444         264 :         if (comment && *comment && !dopt->no_comments)
    3445             :         {
    3446         102 :             resetPQExpBuffer(dbQry);
    3447             : 
    3448             :             /*
    3449             :              * Generates warning when loaded into a differently-named
    3450             :              * database.
    3451             :              */
    3452         102 :             appendPQExpBuffer(dbQry, "COMMENT ON DATABASE %s IS ", qdatname);
    3453         102 :             appendStringLiteralAH(dbQry, comment, fout);
    3454         102 :             appendPQExpBufferStr(dbQry, ";\n");
    3455             : 
    3456         102 :             ArchiveEntry(fout, nilCatalogId, createDumpId(),
    3457         102 :                          ARCHIVE_OPTS(.tag = labelq->data,
    3458             :                                       .owner = dba,
    3459             :                                       .description = "COMMENT",
    3460             :                                       .section = SECTION_NONE,
    3461             :                                       .createStmt = dbQry->data,
    3462             :                                       .deps = &dbDumpId,
    3463             :                                       .nDeps = 1));
    3464             :         }
    3465             :     }
    3466             : 
    3467             :     /* Dump DB security label, if enabled */
    3468         264 :     if (!dopt->no_security_labels)
    3469             :     {
    3470             :         PGresult   *shres;
    3471             :         PQExpBuffer seclabelQry;
    3472             : 
    3473         264 :         seclabelQry = createPQExpBuffer();
    3474             : 
    3475         264 :         buildShSecLabelQuery("pg_database", dbCatId.oid, seclabelQry);
    3476         264 :         shres = ExecuteSqlQuery(fout, seclabelQry->data, PGRES_TUPLES_OK);
    3477         264 :         resetPQExpBuffer(seclabelQry);
    3478         264 :         emitShSecLabels(conn, shres, seclabelQry, "DATABASE", datname);
    3479         264 :         if (seclabelQry->len > 0)
    3480           0 :             ArchiveEntry(fout, nilCatalogId, createDumpId(),
    3481           0 :                          ARCHIVE_OPTS(.tag = labelq->data,
    3482             :                                       .owner = dba,
    3483             :                                       .description = "SECURITY LABEL",
    3484             :                                       .section = SECTION_NONE,
    3485             :                                       .createStmt = seclabelQry->data,
    3486             :                                       .deps = &dbDumpId,
    3487             :                                       .nDeps = 1));
    3488         264 :         destroyPQExpBuffer(seclabelQry);
    3489         264 :         PQclear(shres);
    3490             :     }
    3491             : 
    3492             :     /*
    3493             :      * Dump ACL if any.  Note that we do not support initial privileges
    3494             :      * (pg_init_privs) on databases.
    3495             :      */
    3496         264 :     dbdacl.privtype = 0;
    3497         264 :     dbdacl.initprivs = NULL;
    3498             : 
    3499         264 :     dumpACL(fout, dbDumpId, InvalidDumpId, "DATABASE",
    3500             :             qdatname, NULL, NULL,
    3501             :             NULL, dba, &dbdacl);
    3502             : 
    3503             :     /*
    3504             :      * Now construct a DATABASE PROPERTIES archive entry to restore any
    3505             :      * non-default database-level properties.  (The reason this must be
    3506             :      * separate is that we cannot put any additional commands into the TOC
    3507             :      * entry that has CREATE DATABASE.  pg_restore would execute such a group
    3508             :      * in an implicit transaction block, and the backend won't allow CREATE
    3509             :      * DATABASE in that context.)
    3510             :      */
    3511         264 :     resetPQExpBuffer(creaQry);
    3512         264 :     resetPQExpBuffer(delQry);
    3513             : 
    3514         264 :     if (strlen(datconnlimit) > 0 && strcmp(datconnlimit, "-1") != 0)
    3515           0 :         appendPQExpBuffer(creaQry, "ALTER DATABASE %s CONNECTION LIMIT = %s;\n",
    3516             :                           qdatname, datconnlimit);
    3517             : 
    3518         264 :     if (strcmp(datistemplate, "t") == 0)
    3519             :     {
    3520          34 :         appendPQExpBuffer(creaQry, "ALTER DATABASE %s IS_TEMPLATE = true;\n",
    3521             :                           qdatname);
    3522             : 
    3523             :         /*
    3524             :          * The backend won't accept DROP DATABASE on a template database.  We
    3525             :          * can deal with that by removing the template marking before the DROP
    3526             :          * gets issued.  We'd prefer to use ALTER DATABASE IF EXISTS here, but
    3527             :          * since no such command is currently supported, fake it with a direct
    3528             :          * UPDATE on pg_database.
    3529             :          */
    3530          34 :         appendPQExpBufferStr(delQry, "UPDATE pg_catalog.pg_database "
    3531             :                              "SET datistemplate = false WHERE datname = ");
    3532          34 :         appendStringLiteralAH(delQry, datname, fout);
    3533          34 :         appendPQExpBufferStr(delQry, ";\n");
    3534             :     }
    3535             : 
    3536             :     /*
    3537             :      * We do not restore pg_database.dathasloginevt because it is set
    3538             :      * automatically on login event trigger creation.
    3539             :      */
    3540             : 
    3541             :     /* Add database-specific SET options */
    3542         264 :     dumpDatabaseConfig(fout, creaQry, datname, dbCatId.oid);
    3543             : 
    3544             :     /*
    3545             :      * We stick this binary-upgrade query into the DATABASE PROPERTIES archive
    3546             :      * entry, too, for lack of a better place.
    3547             :      */
    3548         264 :     if (dopt->binary_upgrade)
    3549             :     {
    3550          60 :         appendPQExpBufferStr(creaQry, "\n-- For binary upgrade, set datfrozenxid and datminmxid.\n");
    3551          60 :         appendPQExpBuffer(creaQry, "UPDATE pg_catalog.pg_database\n"
    3552             :                           "SET datfrozenxid = '%u', datminmxid = '%u'\n"
    3553             :                           "WHERE datname = ",
    3554             :                           frozenxid, minmxid);
    3555          60 :         appendStringLiteralAH(creaQry, datname, fout);
    3556          60 :         appendPQExpBufferStr(creaQry, ";\n");
    3557             :     }
    3558             : 
    3559         264 :     if (creaQry->len > 0)
    3560          84 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
    3561          84 :                      ARCHIVE_OPTS(.tag = datname,
    3562             :                                   .owner = dba,
    3563             :                                   .description = "DATABASE PROPERTIES",
    3564             :                                   .section = SECTION_PRE_DATA,
    3565             :                                   .createStmt = creaQry->data,
    3566             :                                   .dropStmt = delQry->data,
    3567             :                                   .deps = &dbDumpId));
    3568             : 
    3569             :     /*
    3570             :      * pg_largeobject comes from the old system intact, so set its
    3571             :      * relfrozenxids, relminmxids and relfilenode.
    3572             :      */
    3573         264 :     if (dopt->binary_upgrade)
    3574             :     {
    3575             :         PGresult   *lo_res;
    3576          60 :         PQExpBuffer loFrozenQry = createPQExpBuffer();
    3577          60 :         PQExpBuffer loOutQry = createPQExpBuffer();
    3578          60 :         PQExpBuffer loHorizonQry = createPQExpBuffer();
    3579             :         int         ii_relfrozenxid,
    3580             :                     ii_relfilenode,
    3581             :                     ii_oid,
    3582             :                     ii_relminmxid;
    3583             : 
    3584             :         /*
    3585             :          * pg_largeobject
    3586             :          */
    3587          60 :         if (fout->remoteVersion >= 90300)
    3588          60 :             appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, relminmxid, relfilenode, oid\n"
    3589             :                               "FROM pg_catalog.pg_class\n"
    3590             :                               "WHERE oid IN (%u, %u);\n",
    3591             :                               LargeObjectRelationId, LargeObjectLOidPNIndexId);
    3592             :         else
    3593           0 :             appendPQExpBuffer(loFrozenQry, "SELECT relfrozenxid, 0 AS relminmxid, relfilenode, oid\n"
    3594             :                               "FROM pg_catalog.pg_class\n"
    3595             :                               "WHERE oid IN (%u, %u);\n",
    3596             :                               LargeObjectRelationId, LargeObjectLOidPNIndexId);
    3597             : 
    3598          60 :         lo_res = ExecuteSqlQuery(fout, loFrozenQry->data, PGRES_TUPLES_OK);
    3599             : 
    3600          60 :         ii_relfrozenxid = PQfnumber(lo_res, "relfrozenxid");
    3601          60 :         ii_relminmxid = PQfnumber(lo_res, "relminmxid");
    3602          60 :         ii_relfilenode = PQfnumber(lo_res, "relfilenode");
    3603          60 :         ii_oid = PQfnumber(lo_res, "oid");
    3604             : 
    3605          60 :         appendPQExpBufferStr(loHorizonQry, "\n-- For binary upgrade, set pg_largeobject relfrozenxid and relminmxid\n");
    3606          60 :         appendPQExpBufferStr(loOutQry, "\n-- For binary upgrade, preserve pg_largeobject and index relfilenodes\n");
    3607         180 :         for (int i = 0; i < PQntuples(lo_res); ++i)
    3608             :         {
    3609             :             Oid         oid;
    3610             :             RelFileNumber relfilenumber;
    3611             : 
    3612         120 :             appendPQExpBuffer(loHorizonQry, "UPDATE pg_catalog.pg_class\n"
    3613             :                               "SET relfrozenxid = '%u', relminmxid = '%u'\n"
    3614             :                               "WHERE oid = %u;\n",
    3615         120 :                               atooid(PQgetvalue(lo_res, i, ii_relfrozenxid)),
    3616         120 :                               atooid(PQgetvalue(lo_res, i, ii_relminmxid)),
    3617         120 :                               atooid(PQgetvalue(lo_res, i, ii_oid)));
    3618             : 
    3619         120 :             oid = atooid(PQgetvalue(lo_res, i, ii_oid));
    3620         120 :             relfilenumber = atooid(PQgetvalue(lo_res, i, ii_relfilenode));
    3621             : 
    3622         120 :             if (oid == LargeObjectRelationId)
    3623          60 :                 appendPQExpBuffer(loOutQry,
    3624             :                                   "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
    3625             :                                   relfilenumber);
    3626          60 :             else if (oid == LargeObjectLOidPNIndexId)
    3627          60 :                 appendPQExpBuffer(loOutQry,
    3628             :                                   "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
    3629             :                                   relfilenumber);
    3630             :         }
    3631             : 
    3632          60 :         appendPQExpBufferStr(loOutQry,
    3633             :                              "TRUNCATE pg_catalog.pg_largeobject;\n");
    3634          60 :         appendPQExpBufferStr(loOutQry, loHorizonQry->data);
    3635             : 
    3636          60 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
    3637          60 :                      ARCHIVE_OPTS(.tag = "pg_largeobject",
    3638             :                                   .description = "pg_largeobject",
    3639             :                                   .section = SECTION_PRE_DATA,
    3640             :                                   .createStmt = loOutQry->data));
    3641             : 
    3642          60 :         PQclear(lo_res);
    3643             : 
    3644          60 :         destroyPQExpBuffer(loFrozenQry);
    3645          60 :         destroyPQExpBuffer(loHorizonQry);
    3646          60 :         destroyPQExpBuffer(loOutQry);
    3647             :     }
    3648             : 
    3649         264 :     PQclear(res);
    3650             : 
    3651         264 :     free(qdatname);
    3652         264 :     destroyPQExpBuffer(dbQry);
    3653         264 :     destroyPQExpBuffer(delQry);
    3654         264 :     destroyPQExpBuffer(creaQry);
    3655         264 :     destroyPQExpBuffer(labelq);
    3656         264 : }
    3657             : 
    3658             : /*
    3659             :  * Collect any database-specific or role-and-database-specific SET options
    3660             :  * for this database, and append them to outbuf.
    3661             :  */
    3662             : static void
    3663         264 : dumpDatabaseConfig(Archive *AH, PQExpBuffer outbuf,
    3664             :                    const char *dbname, Oid dboid)
    3665             : {
    3666         264 :     PGconn     *conn = GetConnection(AH);
    3667         264 :     PQExpBuffer buf = createPQExpBuffer();
    3668             :     PGresult   *res;
    3669             : 
    3670             :     /* First collect database-specific options */
    3671         264 :     printfPQExpBuffer(buf, "SELECT unnest(setconfig) FROM pg_db_role_setting "
    3672             :                       "WHERE setrole = 0 AND setdatabase = '%u'::oid",
    3673             :                       dboid);
    3674             : 
    3675         264 :     res = ExecuteSqlQuery(AH, buf->data, PGRES_TUPLES_OK);
    3676             : 
    3677         336 :     for (int i = 0; i < PQntuples(res); i++)
    3678          72 :         makeAlterConfigCommand(conn, PQgetvalue(res, i, 0),
    3679             :                                "DATABASE", dbname, NULL, NULL,
    3680             :                                outbuf);
    3681             : 
    3682         264 :     PQclear(res);
    3683             : 
    3684             :     /* Now look for role-and-database-specific options */
    3685         264 :     printfPQExpBuffer(buf, "SELECT rolname, unnest(setconfig) "
    3686             :                       "FROM pg_db_role_setting s, pg_roles r "
    3687             :                       "WHERE setrole = r.oid AND setdatabase = '%u'::oid",
    3688             :                       dboid);
    3689             : 
    3690         264 :     res = ExecuteSqlQuery(AH, buf->data, PGRES_TUPLES_OK);
    3691             : 
    3692         264 :     for (int i = 0; i < PQntuples(res); i++)
    3693           0 :         makeAlterConfigCommand(conn, PQgetvalue(res, i, 1),
    3694           0 :                                "ROLE", PQgetvalue(res, i, 0),
    3695             :                                "DATABASE", dbname,
    3696             :                                outbuf);
    3697             : 
    3698         264 :     PQclear(res);
    3699             : 
    3700         264 :     destroyPQExpBuffer(buf);
    3701         264 : }
    3702             : 
    3703             : /*
    3704             :  * dumpEncoding: put the correct encoding into the archive
    3705             :  */
    3706             : static void
    3707         468 : dumpEncoding(Archive *AH)
    3708             : {
    3709         468 :     const char *encname = pg_encoding_to_char(AH->encoding);
    3710         468 :     PQExpBuffer qry = createPQExpBuffer();
    3711             : 
    3712         468 :     pg_log_info("saving encoding = %s", encname);
    3713             : 
    3714         468 :     appendPQExpBufferStr(qry, "SET client_encoding = ");
    3715         468 :     appendStringLiteralAH(qry, encname, AH);
    3716         468 :     appendPQExpBufferStr(qry, ";\n");
    3717             : 
    3718         468 :     ArchiveEntry(AH, nilCatalogId, createDumpId(),
    3719         468 :                  ARCHIVE_OPTS(.tag = "ENCODING",
    3720             :                               .description = "ENCODING",
    3721             :                               .section = SECTION_PRE_DATA,
    3722             :                               .createStmt = qry->data));
    3723             : 
    3724         468 :     destroyPQExpBuffer(qry);
    3725         468 : }
    3726             : 
    3727             : 
    3728             : /*
    3729             :  * dumpStdStrings: put the correct escape string behavior into the archive
    3730             :  */
    3731             : static void
    3732         468 : dumpStdStrings(Archive *AH)
    3733             : {
    3734         468 :     const char *stdstrings = AH->std_strings ? "on" : "off";
    3735         468 :     PQExpBuffer qry = createPQExpBuffer();
    3736             : 
    3737         468 :     pg_log_info("saving \"standard_conforming_strings = %s\"",
    3738             :                 stdstrings);
    3739             : 
    3740         468 :     appendPQExpBuffer(qry, "SET standard_conforming_strings = '%s';\n",
    3741             :                       stdstrings);
    3742             : 
    3743         468 :     ArchiveEntry(AH, nilCatalogId, createDumpId(),
    3744         468 :                  ARCHIVE_OPTS(.tag = "STDSTRINGS",
    3745             :                               .description = "STDSTRINGS",
    3746             :                               .section = SECTION_PRE_DATA,
    3747             :                               .createStmt = qry->data));
    3748             : 
    3749         468 :     destroyPQExpBuffer(qry);
    3750         468 : }
    3751             : 
    3752             : /*
    3753             :  * dumpSearchPath: record the active search_path in the archive
    3754             :  */
    3755             : static void
    3756         468 : dumpSearchPath(Archive *AH)
    3757             : {
    3758         468 :     PQExpBuffer qry = createPQExpBuffer();
    3759         468 :     PQExpBuffer path = createPQExpBuffer();
    3760             :     PGresult   *res;
    3761         468 :     char      **schemanames = NULL;
    3762         468 :     int         nschemanames = 0;
    3763             :     int         i;
    3764             : 
    3765             :     /*
    3766             :      * We use the result of current_schemas(), not the search_path GUC,
    3767             :      * because that might contain wildcards such as "$user", which won't
    3768             :      * necessarily have the same value during restore.  Also, this way avoids
    3769             :      * listing schemas that may appear in search_path but not actually exist,
    3770             :      * which seems like a prudent exclusion.
    3771             :      */
    3772         468 :     res = ExecuteSqlQueryForSingleRow(AH,
    3773             :                                       "SELECT pg_catalog.current_schemas(false)");
    3774             : 
    3775         468 :     if (!parsePGArray(PQgetvalue(res, 0, 0), &schemanames, &nschemanames))
    3776           0 :         pg_fatal("could not parse result of current_schemas()");
    3777             : 
    3778             :     /*
    3779             :      * We use set_config(), not a simple "SET search_path" command, because
    3780             :      * the latter has less-clean behavior if the search path is empty.  While
    3781             :      * that's likely to get fixed at some point, it seems like a good idea to
    3782             :      * be as backwards-compatible as possible in what we put into archives.
    3783             :      */
    3784         468 :     for (i = 0; i < nschemanames; i++)
    3785             :     {
    3786           0 :         if (i > 0)
    3787           0 :             appendPQExpBufferStr(path, ", ");
    3788           0 :         appendPQExpBufferStr(path, fmtId(schemanames[i]));
    3789             :     }
    3790             : 
    3791         468 :     appendPQExpBufferStr(qry, "SELECT pg_catalog.set_config('search_path', ");
    3792         468 :     appendStringLiteralAH(qry, path->data, AH);
    3793         468 :     appendPQExpBufferStr(qry, ", false);\n");
    3794             : 
    3795         468 :     pg_log_info("saving \"search_path = %s\"", path->data);
    3796             : 
    3797         468 :     ArchiveEntry(AH, nilCatalogId, createDumpId(),
    3798         468 :                  ARCHIVE_OPTS(.tag = "SEARCHPATH",
    3799             :                               .description = "SEARCHPATH",
    3800             :                               .section = SECTION_PRE_DATA,
    3801             :                               .createStmt = qry->data));
    3802             : 
    3803             :     /* Also save it in AH->searchpath, in case we're doing plain text dump */
    3804         468 :     AH->searchpath = pg_strdup(qry->data);
    3805             : 
    3806         468 :     free(schemanames);
    3807         468 :     PQclear(res);
    3808         468 :     destroyPQExpBuffer(qry);
    3809         468 :     destroyPQExpBuffer(path);
    3810         468 : }
    3811             : 
    3812             : 
    3813             : /*
    3814             :  * getLOs:
    3815             :  *  Collect schema-level data about large objects
    3816             :  */
    3817             : static void
    3818         410 : getLOs(Archive *fout)
    3819             : {
    3820         410 :     DumpOptions *dopt = fout->dopt;
    3821         410 :     PQExpBuffer loQry = createPQExpBuffer();
    3822             :     PGresult   *res;
    3823             :     int         ntups;
    3824             :     int         i;
    3825             :     int         n;
    3826             :     int         i_oid;
    3827             :     int         i_lomowner;
    3828             :     int         i_lomacl;
    3829             :     int         i_acldefault;
    3830             : 
    3831         410 :     pg_log_info("reading large objects");
    3832             : 
    3833             :     /*
    3834             :      * Fetch LO OIDs and owner/ACL data.  Order the data so that all the blobs
    3835             :      * with the same owner/ACL appear together.
    3836             :      */
    3837         410 :     appendPQExpBufferStr(loQry,
    3838             :                          "SELECT oid, lomowner, lomacl, "
    3839             :                          "acldefault('L', lomowner) AS acldefault "
    3840             :                          "FROM pg_largeobject_metadata "
    3841             :                          "ORDER BY lomowner, lomacl::pg_catalog.text, oid");
    3842             : 
    3843         410 :     res = ExecuteSqlQuery(fout, loQry->data, PGRES_TUPLES_OK);
    3844             : 
    3845         410 :     i_oid = PQfnumber(res, "oid");
    3846         410 :     i_lomowner = PQfnumber(res, "lomowner");
    3847         410 :     i_lomacl = PQfnumber(res, "lomacl");
    3848         410 :     i_acldefault = PQfnumber(res, "acldefault");
    3849             : 
    3850         410 :     ntups = PQntuples(res);
    3851             : 
    3852             :     /*
    3853             :      * Group the blobs into suitably-sized groups that have the same owner and
    3854             :      * ACL setting, and build a metadata and a data DumpableObject for each
    3855             :      * group.  (If we supported initprivs for blobs, we'd have to insist that
    3856             :      * groups also share initprivs settings, since the DumpableObject only has
    3857             :      * room for one.)  i is the index of the first tuple in the current group,
    3858             :      * and n is the number of tuples we include in the group.
    3859             :      */
    3860         574 :     for (i = 0; i < ntups; i += n)
    3861             :     {
    3862         164 :         Oid         thisoid = atooid(PQgetvalue(res, i, i_oid));
    3863         164 :         char       *thisowner = PQgetvalue(res, i, i_lomowner);
    3864         164 :         char       *thisacl = PQgetvalue(res, i, i_lomacl);
    3865             :         LoInfo     *loinfo;
    3866             :         DumpableObject *lodata;
    3867             :         char        namebuf[64];
    3868             : 
    3869             :         /* Scan to find first tuple not to be included in group */
    3870         164 :         n = 1;
    3871         196 :         while (n < MAX_BLOBS_PER_ARCHIVE_ENTRY && i + n < ntups)
    3872             :         {
    3873         106 :             if (strcmp(thisowner, PQgetvalue(res, i + n, i_lomowner)) != 0 ||
    3874         106 :                 strcmp(thisacl, PQgetvalue(res, i + n, i_lomacl)) != 0)
    3875             :                 break;
    3876          32 :             n++;
    3877             :         }
    3878             : 
    3879             :         /* Build the metadata DumpableObject */
    3880         164 :         loinfo = (LoInfo *) pg_malloc(offsetof(LoInfo, looids) + n * sizeof(Oid));
    3881             : 
    3882         164 :         loinfo->dobj.objType = DO_LARGE_OBJECT;
    3883         164 :         loinfo->dobj.catId.tableoid = LargeObjectRelationId;
    3884         164 :         loinfo->dobj.catId.oid = thisoid;
    3885         164 :         AssignDumpId(&loinfo->dobj);
    3886             : 
    3887         164 :         if (n > 1)
    3888          16 :             snprintf(namebuf, sizeof(namebuf), "%u..%u", thisoid,
    3889          16 :                      atooid(PQgetvalue(res, i + n - 1, i_oid)));
    3890             :         else
    3891         148 :             snprintf(namebuf, sizeof(namebuf), "%u", thisoid);
    3892         164 :         loinfo->dobj.name = pg_strdup(namebuf);
    3893         164 :         loinfo->dacl.acl = pg_strdup(thisacl);
    3894         164 :         loinfo->dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    3895         164 :         loinfo->dacl.privtype = 0;
    3896         164 :         loinfo->dacl.initprivs = NULL;
    3897         164 :         loinfo->rolname = getRoleName(thisowner);
    3898         164 :         loinfo->numlos = n;
    3899         164 :         loinfo->looids[0] = thisoid;
    3900             :         /* Collect OIDs of the remaining blobs in this group */
    3901         196 :         for (int k = 1; k < n; k++)
    3902             :         {
    3903             :             CatalogId   extraID;
    3904             : 
    3905          32 :             loinfo->looids[k] = atooid(PQgetvalue(res, i + k, i_oid));
    3906             : 
    3907             :             /* Make sure we can look up loinfo by any of the blobs' OIDs */
    3908          32 :             extraID.tableoid = LargeObjectRelationId;
    3909          32 :             extraID.oid = loinfo->looids[k];
    3910          32 :             recordAdditionalCatalogID(extraID, &loinfo->dobj);
    3911             :         }
    3912             : 
    3913             :         /* LOs have data */
    3914         164 :         loinfo->dobj.components |= DUMP_COMPONENT_DATA;
    3915             : 
    3916             :         /* Mark whether LO group has a non-empty ACL */
    3917         164 :         if (!PQgetisnull(res, i, i_lomacl))
    3918          74 :             loinfo->dobj.components |= DUMP_COMPONENT_ACL;
    3919             : 
    3920             :         /*
    3921             :          * In binary-upgrade mode for LOs, we do *not* dump out the LO data,
    3922             :          * as it will be copied by pg_upgrade, which simply copies the
    3923             :          * pg_largeobject table. We *do* however dump out anything but the
    3924             :          * data, as pg_upgrade copies just pg_largeobject, but not
    3925             :          * pg_largeobject_metadata, after the dump is restored.
    3926             :          */
    3927         164 :         if (dopt->binary_upgrade)
    3928           6 :             loinfo->dobj.dump &= ~DUMP_COMPONENT_DATA;
    3929             : 
    3930             :         /*
    3931             :          * Create a "BLOBS" data item for the group, too. This is just a
    3932             :          * placeholder for sorting; it carries no data now.
    3933             :          */
    3934         164 :         lodata = (DumpableObject *) pg_malloc(sizeof(DumpableObject));
    3935         164 :         lodata->objType = DO_LARGE_OBJECT_DATA;
    3936         164 :         lodata->catId = nilCatalogId;
    3937         164 :         AssignDumpId(lodata);
    3938         164 :         lodata->name = pg_strdup(namebuf);
    3939         164 :         lodata->components |= DUMP_COMPONENT_DATA;
    3940             :         /* Set up explicit dependency from data to metadata */
    3941         164 :         lodata->dependencies = (DumpId *) pg_malloc(sizeof(DumpId));
    3942         164 :         lodata->dependencies[0] = loinfo->dobj.dumpId;
    3943         164 :         lodata->nDeps = lodata->allocDeps = 1;
    3944             :     }
    3945             : 
    3946         410 :     PQclear(res);
    3947         410 :     destroyPQExpBuffer(loQry);
    3948         410 : }
    3949             : 
    3950             : /*
    3951             :  * dumpLO
    3952             :  *
    3953             :  * dump the definition (metadata) of the given large object group
    3954             :  */
    3955             : static void
    3956         164 : dumpLO(Archive *fout, const LoInfo *loinfo)
    3957             : {
    3958         164 :     PQExpBuffer cquery = createPQExpBuffer();
    3959             : 
    3960             :     /*
    3961             :      * The "definition" is just a newline-separated list of OIDs.  We need to
    3962             :      * put something into the dropStmt too, but it can just be a comment.
    3963             :      */
    3964         360 :     for (int i = 0; i < loinfo->numlos; i++)
    3965         196 :         appendPQExpBuffer(cquery, "%u\n", loinfo->looids[i]);
    3966             : 
    3967         164 :     if (loinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    3968         164 :         ArchiveEntry(fout, loinfo->dobj.catId, loinfo->dobj.dumpId,
    3969         164 :                      ARCHIVE_OPTS(.tag = loinfo->dobj.name,
    3970             :                                   .owner = loinfo->rolname,
    3971             :                                   .description = "BLOB METADATA",
    3972             :                                   .section = SECTION_DATA,
    3973             :                                   .createStmt = cquery->data,
    3974             :                                   .dropStmt = "-- dummy"));
    3975             : 
    3976             :     /*
    3977             :      * Dump per-blob comments and seclabels if any.  We assume these are rare
    3978             :      * enough that it's okay to generate retail TOC entries for them.
    3979             :      */
    3980         164 :     if (loinfo->dobj.dump & (DUMP_COMPONENT_COMMENT |
    3981             :                              DUMP_COMPONENT_SECLABEL))
    3982             :     {
    3983         212 :         for (int i = 0; i < loinfo->numlos; i++)
    3984             :         {
    3985             :             CatalogId   catId;
    3986             :             char        namebuf[32];
    3987             : 
    3988             :             /* Build identifying info for this blob */
    3989         122 :             catId.tableoid = loinfo->dobj.catId.tableoid;
    3990         122 :             catId.oid = loinfo->looids[i];
    3991         122 :             snprintf(namebuf, sizeof(namebuf), "%u", loinfo->looids[i]);
    3992             : 
    3993         122 :             if (loinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
    3994         122 :                 dumpComment(fout, "LARGE OBJECT", namebuf,
    3995             :                             NULL, loinfo->rolname,
    3996             :                             catId, 0, loinfo->dobj.dumpId);
    3997             : 
    3998         122 :             if (loinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
    3999           0 :                 dumpSecLabel(fout, "LARGE OBJECT", namebuf,
    4000             :                              NULL, loinfo->rolname,
    4001             :                              catId, 0, loinfo->dobj.dumpId);
    4002             :         }
    4003             :     }
    4004             : 
    4005             :     /*
    4006             :      * Dump the ACLs if any (remember that all blobs in the group will have
    4007             :      * the same ACL).  If there's just one blob, dump a simple ACL entry; if
    4008             :      * there's more, make a "LARGE OBJECTS" entry that really contains only
    4009             :      * the ACL for the first blob.  _printTocEntry() will be cued by the tag
    4010             :      * string to emit a mutated version for each blob.
    4011             :      */
    4012         164 :     if (loinfo->dobj.dump & DUMP_COMPONENT_ACL)
    4013             :     {
    4014             :         char        namebuf[32];
    4015             : 
    4016             :         /* Build identifying info for the first blob */
    4017          74 :         snprintf(namebuf, sizeof(namebuf), "%u", loinfo->looids[0]);
    4018             : 
    4019          74 :         if (loinfo->numlos > 1)
    4020             :         {
    4021             :             char        tagbuf[64];
    4022             : 
    4023           0 :             snprintf(tagbuf, sizeof(tagbuf), "LARGE OBJECTS %u..%u",
    4024           0 :                      loinfo->looids[0], loinfo->looids[loinfo->numlos - 1]);
    4025             : 
    4026           0 :             dumpACL(fout, loinfo->dobj.dumpId, InvalidDumpId,
    4027             :                     "LARGE OBJECT", namebuf, NULL, NULL,
    4028             :                     tagbuf, loinfo->rolname, &loinfo->dacl);
    4029             :         }
    4030             :         else
    4031             :         {
    4032          74 :             dumpACL(fout, loinfo->dobj.dumpId, InvalidDumpId,
    4033             :                     "LARGE OBJECT", namebuf, NULL, NULL,
    4034             :                     NULL, loinfo->rolname, &loinfo->dacl);
    4035             :         }
    4036             :     }
    4037             : 
    4038         164 :     destroyPQExpBuffer(cquery);
    4039         164 : }
    4040             : 
    4041             : /*
    4042             :  * dumpLOs:
    4043             :  *  dump the data contents of the large objects in the given group
    4044             :  */
    4045             : static int
    4046         150 : dumpLOs(Archive *fout, const void *arg)
    4047             : {
    4048         150 :     const LoInfo *loinfo = (const LoInfo *) arg;
    4049         150 :     PGconn     *conn = GetConnection(fout);
    4050             :     char        buf[LOBBUFSIZE];
    4051             : 
    4052         150 :     pg_log_info("saving large objects \"%s\"", loinfo->dobj.name);
    4053             : 
    4054         328 :     for (int i = 0; i < loinfo->numlos; i++)
    4055             :     {
    4056         178 :         Oid         loOid = loinfo->looids[i];
    4057             :         int         loFd;
    4058             :         int         cnt;
    4059             : 
    4060             :         /* Open the LO */
    4061         178 :         loFd = lo_open(conn, loOid, INV_READ);
    4062         178 :         if (loFd == -1)
    4063           0 :             pg_fatal("could not open large object %u: %s",
    4064             :                      loOid, PQerrorMessage(conn));
    4065             : 
    4066         178 :         StartLO(fout, loOid);
    4067             : 
    4068             :         /* Now read it in chunks, sending data to archive */
    4069             :         do
    4070             :         {
    4071         274 :             cnt = lo_read(conn, loFd, buf, LOBBUFSIZE);
    4072         274 :             if (cnt < 0)
    4073           0 :                 pg_fatal("error reading large object %u: %s",
    4074             :                          loOid, PQerrorMessage(conn));
    4075             : 
    4076         274 :             WriteData(fout, buf, cnt);
    4077         274 :         } while (cnt > 0);
    4078             : 
    4079         178 :         lo_close(conn, loFd);
    4080             : 
    4081         178 :         EndLO(fout, loOid);
    4082             :     }
    4083             : 
    4084         150 :     return 1;
    4085             : }
    4086             : 
    4087             : /*
    4088             :  * getPolicies
    4089             :  *    get information about all RLS policies on dumpable tables.
    4090             :  */
    4091             : void
    4092         468 : getPolicies(Archive *fout, TableInfo tblinfo[], int numTables)
    4093             : {
    4094         468 :     DumpOptions *dopt = fout->dopt;
    4095             :     PQExpBuffer query;
    4096             :     PQExpBuffer tbloids;
    4097             :     PGresult   *res;
    4098             :     PolicyInfo *polinfo;
    4099             :     int         i_oid;
    4100             :     int         i_tableoid;
    4101             :     int         i_polrelid;
    4102             :     int         i_polname;
    4103             :     int         i_polcmd;
    4104             :     int         i_polpermissive;
    4105             :     int         i_polroles;
    4106             :     int         i_polqual;
    4107             :     int         i_polwithcheck;
    4108             :     int         i,
    4109             :                 j,
    4110             :                 ntups;
    4111             : 
    4112             :     /* No policies before 9.5 */
    4113         468 :     if (fout->remoteVersion < 90500)
    4114           0 :         return;
    4115             : 
    4116             :     /* Skip if --no-policies was specified */
    4117         468 :     if (dopt->no_policies)
    4118           2 :         return;
    4119             : 
    4120         466 :     query = createPQExpBuffer();
    4121         466 :     tbloids = createPQExpBuffer();
    4122             : 
    4123             :     /*
    4124             :      * Identify tables of interest, and check which ones have RLS enabled.
    4125             :      */
    4126         466 :     appendPQExpBufferChar(tbloids, '{');
    4127      122610 :     for (i = 0; i < numTables; i++)
    4128             :     {
    4129      122144 :         TableInfo  *tbinfo = &tblinfo[i];
    4130             : 
    4131             :         /* Ignore row security on tables not to be dumped */
    4132      122144 :         if (!(tbinfo->dobj.dump & DUMP_COMPONENT_POLICY))
    4133      103416 :             continue;
    4134             : 
    4135             :         /* It can't have RLS or policies if it's not a table */
    4136       18728 :         if (tbinfo->relkind != RELKIND_RELATION &&
    4137        5184 :             tbinfo->relkind != RELKIND_PARTITIONED_TABLE)
    4138        3538 :             continue;
    4139             : 
    4140             :         /* Add it to the list of table OIDs to be probed below */
    4141       15190 :         if (tbloids->len > 1) /* do we have more than the '{'? */
    4142       14878 :             appendPQExpBufferChar(tbloids, ',');
    4143       15190 :         appendPQExpBuffer(tbloids, "%u", tbinfo->dobj.catId.oid);
    4144             : 
    4145             :         /* Is RLS enabled?  (That's separate from whether it has policies) */
    4146       15190 :         if (tbinfo->rowsec)
    4147             :         {
    4148         132 :             tbinfo->dobj.components |= DUMP_COMPONENT_POLICY;
    4149             : 
    4150             :             /*
    4151             :              * We represent RLS being enabled on a table by creating a
    4152             :              * PolicyInfo object with null polname.
    4153             :              *
    4154             :              * Note: use tableoid 0 so that this object won't be mistaken for
    4155             :              * something that pg_depend entries apply to.
    4156             :              */
    4157         132 :             polinfo = pg_malloc(sizeof(PolicyInfo));
    4158         132 :             polinfo->dobj.objType = DO_POLICY;
    4159         132 :             polinfo->dobj.catId.tableoid = 0;
    4160         132 :             polinfo->dobj.catId.oid = tbinfo->dobj.catId.oid;
    4161         132 :             AssignDumpId(&polinfo->dobj);
    4162         132 :             polinfo->dobj.namespace = tbinfo->dobj.namespace;
    4163         132 :             polinfo->dobj.name = pg_strdup(tbinfo->dobj.name);
    4164         132 :             polinfo->poltable = tbinfo;
    4165         132 :             polinfo->polname = NULL;
    4166         132 :             polinfo->polcmd = '\0';
    4167         132 :             polinfo->polpermissive = 0;
    4168         132 :             polinfo->polroles = NULL;
    4169         132 :             polinfo->polqual = NULL;
    4170         132 :             polinfo->polwithcheck = NULL;
    4171             :         }
    4172             :     }
    4173         466 :     appendPQExpBufferChar(tbloids, '}');
    4174             : 
    4175             :     /*
    4176             :      * Now, read all RLS policies belonging to the tables of interest, and
    4177             :      * create PolicyInfo objects for them.  (Note that we must filter the
    4178             :      * results server-side not locally, because we dare not apply pg_get_expr
    4179             :      * to tables we don't have lock on.)
    4180             :      */
    4181         466 :     pg_log_info("reading row-level security policies");
    4182             : 
    4183         466 :     printfPQExpBuffer(query,
    4184             :                       "SELECT pol.oid, pol.tableoid, pol.polrelid, pol.polname, pol.polcmd, ");
    4185         466 :     if (fout->remoteVersion >= 100000)
    4186         466 :         appendPQExpBufferStr(query, "pol.polpermissive, ");
    4187             :     else
    4188           0 :         appendPQExpBufferStr(query, "'t' as polpermissive, ");
    4189         466 :     appendPQExpBuffer(query,
    4190             :                       "CASE WHEN pol.polroles = '{0}' THEN NULL ELSE "
    4191             :                       "   pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(rolname) from pg_catalog.pg_roles WHERE oid = ANY(pol.polroles)), ', ') END AS polroles, "
    4192             :                       "pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS polqual, "
    4193             :                       "pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS polwithcheck "
    4194             :                       "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    4195             :                       "JOIN pg_catalog.pg_policy pol ON (src.tbloid = pol.polrelid)",
    4196             :                       tbloids->data);
    4197             : 
    4198         466 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    4199             : 
    4200         466 :     ntups = PQntuples(res);
    4201         466 :     if (ntups > 0)
    4202             :     {
    4203         100 :         i_oid = PQfnumber(res, "oid");
    4204         100 :         i_tableoid = PQfnumber(res, "tableoid");
    4205         100 :         i_polrelid = PQfnumber(res, "polrelid");
    4206         100 :         i_polname = PQfnumber(res, "polname");
    4207         100 :         i_polcmd = PQfnumber(res, "polcmd");
    4208         100 :         i_polpermissive = PQfnumber(res, "polpermissive");
    4209         100 :         i_polroles = PQfnumber(res, "polroles");
    4210         100 :         i_polqual = PQfnumber(res, "polqual");
    4211         100 :         i_polwithcheck = PQfnumber(res, "polwithcheck");
    4212             : 
    4213         100 :         polinfo = pg_malloc(ntups * sizeof(PolicyInfo));
    4214             : 
    4215         748 :         for (j = 0; j < ntups; j++)
    4216             :         {
    4217         648 :             Oid         polrelid = atooid(PQgetvalue(res, j, i_polrelid));
    4218         648 :             TableInfo  *tbinfo = findTableByOid(polrelid);
    4219             : 
    4220         648 :             tbinfo->dobj.components |= DUMP_COMPONENT_POLICY;
    4221             : 
    4222         648 :             polinfo[j].dobj.objType = DO_POLICY;
    4223         648 :             polinfo[j].dobj.catId.tableoid =
    4224         648 :                 atooid(PQgetvalue(res, j, i_tableoid));
    4225         648 :             polinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
    4226         648 :             AssignDumpId(&polinfo[j].dobj);
    4227         648 :             polinfo[j].dobj.namespace = tbinfo->dobj.namespace;
    4228         648 :             polinfo[j].poltable = tbinfo;
    4229         648 :             polinfo[j].polname = pg_strdup(PQgetvalue(res, j, i_polname));
    4230         648 :             polinfo[j].dobj.name = pg_strdup(polinfo[j].polname);
    4231             : 
    4232         648 :             polinfo[j].polcmd = *(PQgetvalue(res, j, i_polcmd));
    4233         648 :             polinfo[j].polpermissive = *(PQgetvalue(res, j, i_polpermissive)) == 't';
    4234             : 
    4235         648 :             if (PQgetisnull(res, j, i_polroles))
    4236         312 :                 polinfo[j].polroles = NULL;
    4237             :             else
    4238         336 :                 polinfo[j].polroles = pg_strdup(PQgetvalue(res, j, i_polroles));
    4239             : 
    4240         648 :             if (PQgetisnull(res, j, i_polqual))
    4241          84 :                 polinfo[j].polqual = NULL;
    4242             :             else
    4243         564 :                 polinfo[j].polqual = pg_strdup(PQgetvalue(res, j, i_polqual));
    4244             : 
    4245         648 :             if (PQgetisnull(res, j, i_polwithcheck))
    4246         348 :                 polinfo[j].polwithcheck = NULL;
    4247             :             else
    4248         300 :                 polinfo[j].polwithcheck
    4249         300 :                     = pg_strdup(PQgetvalue(res, j, i_polwithcheck));
    4250             :         }
    4251             :     }
    4252             : 
    4253         466 :     PQclear(res);
    4254             : 
    4255         466 :     destroyPQExpBuffer(query);
    4256         466 :     destroyPQExpBuffer(tbloids);
    4257             : }
    4258             : 
    4259             : /*
    4260             :  * dumpPolicy
    4261             :  *    dump the definition of the given policy
    4262             :  */
    4263             : static void
    4264         780 : dumpPolicy(Archive *fout, const PolicyInfo *polinfo)
    4265             : {
    4266         780 :     DumpOptions *dopt = fout->dopt;
    4267         780 :     TableInfo  *tbinfo = polinfo->poltable;
    4268             :     PQExpBuffer query;
    4269             :     PQExpBuffer delqry;
    4270             :     PQExpBuffer polprefix;
    4271             :     char       *qtabname;
    4272             :     const char *cmd;
    4273             :     char       *tag;
    4274             : 
    4275             :     /* Do nothing if not dumping schema */
    4276         780 :     if (!dopt->dumpSchema)
    4277          98 :         return;
    4278             : 
    4279             :     /*
    4280             :      * If polname is NULL, then this record is just indicating that ROW LEVEL
    4281             :      * SECURITY is enabled for the table. Dump as ALTER TABLE <table> ENABLE
    4282             :      * ROW LEVEL SECURITY.
    4283             :      */
    4284         682 :     if (polinfo->polname == NULL)
    4285             :     {
    4286         118 :         query = createPQExpBuffer();
    4287             : 
    4288         118 :         appendPQExpBuffer(query, "ALTER TABLE %s ENABLE ROW LEVEL SECURITY;",
    4289         118 :                           fmtQualifiedDumpable(tbinfo));
    4290             : 
    4291             :         /*
    4292             :          * We must emit the ROW SECURITY object's dependency on its table
    4293             :          * explicitly, because it will not match anything in pg_depend (unlike
    4294             :          * the case for other PolicyInfo objects).
    4295             :          */
    4296         118 :         if (polinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    4297         118 :             ArchiveEntry(fout, polinfo->dobj.catId, polinfo->dobj.dumpId,
    4298         118 :                          ARCHIVE_OPTS(.tag = polinfo->dobj.name,
    4299             :                                       .namespace = polinfo->dobj.namespace->dobj.name,
    4300             :                                       .owner = tbinfo->rolname,
    4301             :                                       .description = "ROW SECURITY",
    4302             :                                       .section = SECTION_POST_DATA,
    4303             :                                       .createStmt = query->data,
    4304             :                                       .deps = &(tbinfo->dobj.dumpId),
    4305             :                                       .nDeps = 1));
    4306             : 
    4307         118 :         destroyPQExpBuffer(query);
    4308         118 :         return;
    4309             :     }
    4310             : 
    4311         564 :     if (polinfo->polcmd == '*')
    4312         188 :         cmd = "";
    4313         376 :     else if (polinfo->polcmd == 'r')
    4314         102 :         cmd = " FOR SELECT";
    4315         274 :     else if (polinfo->polcmd == 'a')
    4316          70 :         cmd = " FOR INSERT";
    4317         204 :     else if (polinfo->polcmd == 'w')
    4318         102 :         cmd = " FOR UPDATE";
    4319         102 :     else if (polinfo->polcmd == 'd')
    4320         102 :         cmd = " FOR DELETE";
    4321             :     else
    4322           0 :         pg_fatal("unexpected policy command type: %c",
    4323             :                  polinfo->polcmd);
    4324             : 
    4325         564 :     query = createPQExpBuffer();
    4326         564 :     delqry = createPQExpBuffer();
    4327         564 :     polprefix = createPQExpBuffer();
    4328             : 
    4329         564 :     qtabname = pg_strdup(fmtId(tbinfo->dobj.name));
    4330             : 
    4331         564 :     appendPQExpBuffer(query, "CREATE POLICY %s", fmtId(polinfo->polname));
    4332             : 
    4333         564 :     appendPQExpBuffer(query, " ON %s%s%s", fmtQualifiedDumpable(tbinfo),
    4334         564 :                       !polinfo->polpermissive ? " AS RESTRICTIVE" : "", cmd);
    4335             : 
    4336         564 :     if (polinfo->polroles != NULL)
    4337         280 :         appendPQExpBuffer(query, " TO %s", polinfo->polroles);
    4338             : 
    4339         564 :     if (polinfo->polqual != NULL)
    4340         494 :         appendPQExpBuffer(query, " USING (%s)", polinfo->polqual);
    4341             : 
    4342         564 :     if (polinfo->polwithcheck != NULL)
    4343         258 :         appendPQExpBuffer(query, " WITH CHECK (%s)", polinfo->polwithcheck);
    4344             : 
    4345         564 :     appendPQExpBufferStr(query, ";\n");
    4346             : 
    4347         564 :     appendPQExpBuffer(delqry, "DROP POLICY %s", fmtId(polinfo->polname));
    4348         564 :     appendPQExpBuffer(delqry, " ON %s;\n", fmtQualifiedDumpable(tbinfo));
    4349             : 
    4350         564 :     appendPQExpBuffer(polprefix, "POLICY %s ON",
    4351         564 :                       fmtId(polinfo->polname));
    4352             : 
    4353         564 :     tag = psprintf("%s %s", tbinfo->dobj.name, polinfo->dobj.name);
    4354             : 
    4355         564 :     if (polinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    4356         564 :         ArchiveEntry(fout, polinfo->dobj.catId, polinfo->dobj.dumpId,
    4357         564 :                      ARCHIVE_OPTS(.tag = tag,
    4358             :                                   .namespace = polinfo->dobj.namespace->dobj.name,
    4359             :                                   .owner = tbinfo->rolname,
    4360             :                                   .description = "POLICY",
    4361             :                                   .section = SECTION_POST_DATA,
    4362             :                                   .createStmt = query->data,
    4363             :                                   .dropStmt = delqry->data));
    4364             : 
    4365         564 :     if (polinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
    4366           0 :         dumpComment(fout, polprefix->data, qtabname,
    4367           0 :                     tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
    4368             :                     polinfo->dobj.catId, 0, polinfo->dobj.dumpId);
    4369             : 
    4370         564 :     free(tag);
    4371         564 :     destroyPQExpBuffer(query);
    4372         564 :     destroyPQExpBuffer(delqry);
    4373         564 :     destroyPQExpBuffer(polprefix);
    4374         564 :     free(qtabname);
    4375             : }
    4376             : 
    4377             : /*
    4378             :  * getPublications
    4379             :  *    get information about publications
    4380             :  */
    4381             : void
    4382         468 : getPublications(Archive *fout)
    4383             : {
    4384         468 :     DumpOptions *dopt = fout->dopt;
    4385             :     PQExpBuffer query;
    4386             :     PGresult   *res;
    4387             :     PublicationInfo *pubinfo;
    4388             :     int         i_tableoid;
    4389             :     int         i_oid;
    4390             :     int         i_pubname;
    4391             :     int         i_pubowner;
    4392             :     int         i_puballtables;
    4393             :     int         i_pubinsert;
    4394             :     int         i_pubupdate;
    4395             :     int         i_pubdelete;
    4396             :     int         i_pubtruncate;
    4397             :     int         i_pubviaroot;
    4398             :     int         i_pubgencols;
    4399             :     int         i,
    4400             :                 ntups;
    4401             : 
    4402         468 :     if (dopt->no_publications || fout->remoteVersion < 100000)
    4403           0 :         return;
    4404             : 
    4405         468 :     query = createPQExpBuffer();
    4406             : 
    4407             :     /* Get the publications. */
    4408         468 :     appendPQExpBufferStr(query, "SELECT p.tableoid, p.oid, p.pubname, "
    4409             :                          "p.pubowner, p.puballtables, p.pubinsert, "
    4410             :                          "p.pubupdate, p.pubdelete, ");
    4411             : 
    4412         468 :     if (fout->remoteVersion >= 110000)
    4413         468 :         appendPQExpBufferStr(query, "p.pubtruncate, ");
    4414             :     else
    4415           0 :         appendPQExpBufferStr(query, "false AS pubtruncate, ");
    4416             : 
    4417         468 :     if (fout->remoteVersion >= 130000)
    4418         468 :         appendPQExpBufferStr(query, "p.pubviaroot, ");
    4419             :     else
    4420           0 :         appendPQExpBufferStr(query, "false AS pubviaroot, ");
    4421             : 
    4422         468 :     if (fout->remoteVersion >= 180000)
    4423         468 :         appendPQExpBufferStr(query, "p.pubgencols ");
    4424             :     else
    4425           0 :         appendPQExpBuffer(query, "'%c' AS pubgencols ", PUBLISH_GENCOLS_NONE);
    4426             : 
    4427         468 :     appendPQExpBufferStr(query, "FROM pg_publication p");
    4428             : 
    4429         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    4430             : 
    4431         468 :     ntups = PQntuples(res);
    4432             : 
    4433         468 :     if (ntups == 0)
    4434         368 :         goto cleanup;
    4435             : 
    4436         100 :     i_tableoid = PQfnumber(res, "tableoid");
    4437         100 :     i_oid = PQfnumber(res, "oid");
    4438         100 :     i_pubname = PQfnumber(res, "pubname");
    4439         100 :     i_pubowner = PQfnumber(res, "pubowner");
    4440         100 :     i_puballtables = PQfnumber(res, "puballtables");
    4441         100 :     i_pubinsert = PQfnumber(res, "pubinsert");
    4442         100 :     i_pubupdate = PQfnumber(res, "pubupdate");
    4443         100 :     i_pubdelete = PQfnumber(res, "pubdelete");
    4444         100 :     i_pubtruncate = PQfnumber(res, "pubtruncate");
    4445         100 :     i_pubviaroot = PQfnumber(res, "pubviaroot");
    4446         100 :     i_pubgencols = PQfnumber(res, "pubgencols");
    4447             : 
    4448         100 :     pubinfo = pg_malloc(ntups * sizeof(PublicationInfo));
    4449             : 
    4450         592 :     for (i = 0; i < ntups; i++)
    4451             :     {
    4452         492 :         pubinfo[i].dobj.objType = DO_PUBLICATION;
    4453         492 :         pubinfo[i].dobj.catId.tableoid =
    4454         492 :             atooid(PQgetvalue(res, i, i_tableoid));
    4455         492 :         pubinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    4456         492 :         AssignDumpId(&pubinfo[i].dobj);
    4457         492 :         pubinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_pubname));
    4458         492 :         pubinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_pubowner));
    4459         492 :         pubinfo[i].puballtables =
    4460         492 :             (strcmp(PQgetvalue(res, i, i_puballtables), "t") == 0);
    4461         492 :         pubinfo[i].pubinsert =
    4462         492 :             (strcmp(PQgetvalue(res, i, i_pubinsert), "t") == 0);
    4463         492 :         pubinfo[i].pubupdate =
    4464         492 :             (strcmp(PQgetvalue(res, i, i_pubupdate), "t") == 0);
    4465         492 :         pubinfo[i].pubdelete =
    4466         492 :             (strcmp(PQgetvalue(res, i, i_pubdelete), "t") == 0);
    4467         492 :         pubinfo[i].pubtruncate =
    4468         492 :             (strcmp(PQgetvalue(res, i, i_pubtruncate), "t") == 0);
    4469         492 :         pubinfo[i].pubviaroot =
    4470         492 :             (strcmp(PQgetvalue(res, i, i_pubviaroot), "t") == 0);
    4471         492 :         pubinfo[i].pubgencols_type =
    4472         492 :             *(PQgetvalue(res, i, i_pubgencols));
    4473             : 
    4474             :         /* Decide whether we want to dump it */
    4475         492 :         selectDumpableObject(&(pubinfo[i].dobj), fout);
    4476             :     }
    4477             : 
    4478         100 : cleanup:
    4479         468 :     PQclear(res);
    4480             : 
    4481         468 :     destroyPQExpBuffer(query);
    4482             : }
    4483             : 
    4484             : /*
    4485             :  * dumpPublication
    4486             :  *    dump the definition of the given publication
    4487             :  */
    4488             : static void
    4489         412 : dumpPublication(Archive *fout, const PublicationInfo *pubinfo)
    4490             : {
    4491         412 :     DumpOptions *dopt = fout->dopt;
    4492             :     PQExpBuffer delq;
    4493             :     PQExpBuffer query;
    4494             :     char       *qpubname;
    4495         412 :     bool        first = true;
    4496             : 
    4497             :     /* Do nothing if not dumping schema */
    4498         412 :     if (!dopt->dumpSchema)
    4499          60 :         return;
    4500             : 
    4501         352 :     delq = createPQExpBuffer();
    4502         352 :     query = createPQExpBuffer();
    4503             : 
    4504         352 :     qpubname = pg_strdup(fmtId(pubinfo->dobj.name));
    4505             : 
    4506         352 :     appendPQExpBuffer(delq, "DROP PUBLICATION %s;\n",
    4507             :                       qpubname);
    4508             : 
    4509         352 :     appendPQExpBuffer(query, "CREATE PUBLICATION %s",
    4510             :                       qpubname);
    4511             : 
    4512         352 :     if (pubinfo->puballtables)
    4513          72 :         appendPQExpBufferStr(query, " FOR ALL TABLES");
    4514             : 
    4515         352 :     appendPQExpBufferStr(query, " WITH (publish = '");
    4516         352 :     if (pubinfo->pubinsert)
    4517             :     {
    4518         282 :         appendPQExpBufferStr(query, "insert");
    4519         282 :         first = false;
    4520             :     }
    4521             : 
    4522         352 :     if (pubinfo->pubupdate)
    4523             :     {
    4524         282 :         if (!first)
    4525         282 :             appendPQExpBufferStr(query, ", ");
    4526             : 
    4527         282 :         appendPQExpBufferStr(query, "update");
    4528         282 :         first = false;
    4529             :     }
    4530             : 
    4531         352 :     if (pubinfo->pubdelete)
    4532             :     {
    4533         282 :         if (!first)
    4534         282 :             appendPQExpBufferStr(query, ", ");
    4535             : 
    4536         282 :         appendPQExpBufferStr(query, "delete");
    4537         282 :         first = false;
    4538             :     }
    4539             : 
    4540         352 :     if (pubinfo->pubtruncate)
    4541             :     {
    4542         282 :         if (!first)
    4543         282 :             appendPQExpBufferStr(query, ", ");
    4544             : 
    4545         282 :         appendPQExpBufferStr(query, "truncate");
    4546         282 :         first = false;
    4547             :     }
    4548             : 
    4549         352 :     appendPQExpBufferChar(query, '\'');
    4550             : 
    4551         352 :     if (pubinfo->pubviaroot)
    4552           0 :         appendPQExpBufferStr(query, ", publish_via_partition_root = true");
    4553             : 
    4554         352 :     if (pubinfo->pubgencols_type == PUBLISH_GENCOLS_STORED)
    4555          70 :         appendPQExpBufferStr(query, ", publish_generated_columns = stored");
    4556             : 
    4557         352 :     appendPQExpBufferStr(query, ");\n");
    4558             : 
    4559         352 :     if (pubinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    4560         352 :         ArchiveEntry(fout, pubinfo->dobj.catId, pubinfo->dobj.dumpId,
    4561         352 :                      ARCHIVE_OPTS(.tag = pubinfo->dobj.name,
    4562             :                                   .owner = pubinfo->rolname,
    4563             :                                   .description = "PUBLICATION",
    4564             :                                   .section = SECTION_POST_DATA,
    4565             :                                   .createStmt = query->data,
    4566             :                                   .dropStmt = delq->data));
    4567             : 
    4568         352 :     if (pubinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
    4569          70 :         dumpComment(fout, "PUBLICATION", qpubname,
    4570             :                     NULL, pubinfo->rolname,
    4571             :                     pubinfo->dobj.catId, 0, pubinfo->dobj.dumpId);
    4572             : 
    4573         352 :     if (pubinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
    4574           0 :         dumpSecLabel(fout, "PUBLICATION", qpubname,
    4575             :                      NULL, pubinfo->rolname,
    4576             :                      pubinfo->dobj.catId, 0, pubinfo->dobj.dumpId);
    4577             : 
    4578         352 :     destroyPQExpBuffer(delq);
    4579         352 :     destroyPQExpBuffer(query);
    4580         352 :     free(qpubname);
    4581             : }
    4582             : 
    4583             : /*
    4584             :  * getPublicationNamespaces
    4585             :  *    get information about publication membership for dumpable schemas.
    4586             :  */
    4587             : void
    4588         468 : getPublicationNamespaces(Archive *fout)
    4589             : {
    4590             :     PQExpBuffer query;
    4591             :     PGresult   *res;
    4592             :     PublicationSchemaInfo *pubsinfo;
    4593         468 :     DumpOptions *dopt = fout->dopt;
    4594             :     int         i_tableoid;
    4595             :     int         i_oid;
    4596             :     int         i_pnpubid;
    4597             :     int         i_pnnspid;
    4598             :     int         i,
    4599             :                 j,
    4600             :                 ntups;
    4601             : 
    4602         468 :     if (dopt->no_publications || fout->remoteVersion < 150000)
    4603           0 :         return;
    4604             : 
    4605         468 :     query = createPQExpBuffer();
    4606             : 
    4607             :     /* Collect all publication membership info. */
    4608         468 :     appendPQExpBufferStr(query,
    4609             :                          "SELECT tableoid, oid, pnpubid, pnnspid "
    4610             :                          "FROM pg_catalog.pg_publication_namespace");
    4611         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    4612             : 
    4613         468 :     ntups = PQntuples(res);
    4614             : 
    4615         468 :     i_tableoid = PQfnumber(res, "tableoid");
    4616         468 :     i_oid = PQfnumber(res, "oid");
    4617         468 :     i_pnpubid = PQfnumber(res, "pnpubid");
    4618         468 :     i_pnnspid = PQfnumber(res, "pnnspid");
    4619             : 
    4620             :     /* this allocation may be more than we need */
    4621         468 :     pubsinfo = pg_malloc(ntups * sizeof(PublicationSchemaInfo));
    4622         468 :     j = 0;
    4623             : 
    4624         664 :     for (i = 0; i < ntups; i++)
    4625             :     {
    4626         196 :         Oid         pnpubid = atooid(PQgetvalue(res, i, i_pnpubid));
    4627         196 :         Oid         pnnspid = atooid(PQgetvalue(res, i, i_pnnspid));
    4628             :         PublicationInfo *pubinfo;
    4629             :         NamespaceInfo *nspinfo;
    4630             : 
    4631             :         /*
    4632             :          * Ignore any entries for which we aren't interested in either the
    4633             :          * publication or the rel.
    4634             :          */
    4635         196 :         pubinfo = findPublicationByOid(pnpubid);
    4636         196 :         if (pubinfo == NULL)
    4637           0 :             continue;
    4638         196 :         nspinfo = findNamespaceByOid(pnnspid);
    4639         196 :         if (nspinfo == NULL)
    4640           0 :             continue;
    4641             : 
    4642             :         /* OK, make a DumpableObject for this relationship */
    4643         196 :         pubsinfo[j].dobj.objType = DO_PUBLICATION_TABLE_IN_SCHEMA;
    4644         196 :         pubsinfo[j].dobj.catId.tableoid =
    4645         196 :             atooid(PQgetvalue(res, i, i_tableoid));
    4646         196 :         pubsinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    4647         196 :         AssignDumpId(&pubsinfo[j].dobj);
    4648         196 :         pubsinfo[j].dobj.namespace = nspinfo->dobj.namespace;
    4649         196 :         pubsinfo[j].dobj.name = nspinfo->dobj.name;
    4650         196 :         pubsinfo[j].publication = pubinfo;
    4651         196 :         pubsinfo[j].pubschema = nspinfo;
    4652             : 
    4653             :         /* Decide whether we want to dump it */
    4654         196 :         selectDumpablePublicationObject(&(pubsinfo[j].dobj), fout);
    4655             : 
    4656         196 :         j++;
    4657             :     }
    4658             : 
    4659         468 :     PQclear(res);
    4660         468 :     destroyPQExpBuffer(query);
    4661             : }
    4662             : 
    4663             : /*
    4664             :  * getPublicationTables
    4665             :  *    get information about publication membership for dumpable tables.
    4666             :  */
    4667             : void
    4668         468 : getPublicationTables(Archive *fout, TableInfo tblinfo[], int numTables)
    4669             : {
    4670             :     PQExpBuffer query;
    4671             :     PGresult   *res;
    4672             :     PublicationRelInfo *pubrinfo;
    4673         468 :     DumpOptions *dopt = fout->dopt;
    4674             :     int         i_tableoid;
    4675             :     int         i_oid;
    4676             :     int         i_prpubid;
    4677             :     int         i_prrelid;
    4678             :     int         i_prrelqual;
    4679             :     int         i_prattrs;
    4680             :     int         i,
    4681             :                 j,
    4682             :                 ntups;
    4683             : 
    4684         468 :     if (dopt->no_publications || fout->remoteVersion < 100000)
    4685           0 :         return;
    4686             : 
    4687         468 :     query = createPQExpBuffer();
    4688             : 
    4689             :     /* Collect all publication membership info. */
    4690         468 :     if (fout->remoteVersion >= 150000)
    4691         468 :         appendPQExpBufferStr(query,
    4692             :                              "SELECT tableoid, oid, prpubid, prrelid, "
    4693             :                              "pg_catalog.pg_get_expr(prqual, prrelid) AS prrelqual, "
    4694             :                              "(CASE\n"
    4695             :                              "  WHEN pr.prattrs IS NOT NULL THEN\n"
    4696             :                              "    (SELECT array_agg(attname)\n"
    4697             :                              "       FROM\n"
    4698             :                              "         pg_catalog.generate_series(0, pg_catalog.array_upper(pr.prattrs::pg_catalog.int2[], 1)) s,\n"
    4699             :                              "         pg_catalog.pg_attribute\n"
    4700             :                              "      WHERE attrelid = pr.prrelid AND attnum = prattrs[s])\n"
    4701             :                              "  ELSE NULL END) prattrs "
    4702             :                              "FROM pg_catalog.pg_publication_rel pr");
    4703             :     else
    4704           0 :         appendPQExpBufferStr(query,
    4705             :                              "SELECT tableoid, oid, prpubid, prrelid, "
    4706             :                              "NULL AS prrelqual, NULL AS prattrs "
    4707             :                              "FROM pg_catalog.pg_publication_rel");
    4708         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    4709             : 
    4710         468 :     ntups = PQntuples(res);
    4711             : 
    4712         468 :     i_tableoid = PQfnumber(res, "tableoid");
    4713         468 :     i_oid = PQfnumber(res, "oid");
    4714         468 :     i_prpubid = PQfnumber(res, "prpubid");
    4715         468 :     i_prrelid = PQfnumber(res, "prrelid");
    4716         468 :     i_prrelqual = PQfnumber(res, "prrelqual");
    4717         468 :     i_prattrs = PQfnumber(res, "prattrs");
    4718             : 
    4719             :     /* this allocation may be more than we need */
    4720         468 :     pubrinfo = pg_malloc(ntups * sizeof(PublicationRelInfo));
    4721         468 :     j = 0;
    4722             : 
    4723        1154 :     for (i = 0; i < ntups; i++)
    4724             :     {
    4725         686 :         Oid         prpubid = atooid(PQgetvalue(res, i, i_prpubid));
    4726         686 :         Oid         prrelid = atooid(PQgetvalue(res, i, i_prrelid));
    4727             :         PublicationInfo *pubinfo;
    4728             :         TableInfo  *tbinfo;
    4729             : 
    4730             :         /*
    4731             :          * Ignore any entries for which we aren't interested in either the
    4732             :          * publication or the rel.
    4733             :          */
    4734         686 :         pubinfo = findPublicationByOid(prpubid);
    4735         686 :         if (pubinfo == NULL)
    4736           0 :             continue;
    4737         686 :         tbinfo = findTableByOid(prrelid);
    4738         686 :         if (tbinfo == NULL)
    4739           0 :             continue;
    4740             : 
    4741             :         /* OK, make a DumpableObject for this relationship */
    4742         686 :         pubrinfo[j].dobj.objType = DO_PUBLICATION_REL;
    4743         686 :         pubrinfo[j].dobj.catId.tableoid =
    4744         686 :             atooid(PQgetvalue(res, i, i_tableoid));
    4745         686 :         pubrinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    4746         686 :         AssignDumpId(&pubrinfo[j].dobj);
    4747         686 :         pubrinfo[j].dobj.namespace = tbinfo->dobj.namespace;
    4748         686 :         pubrinfo[j].dobj.name = tbinfo->dobj.name;
    4749         686 :         pubrinfo[j].publication = pubinfo;
    4750         686 :         pubrinfo[j].pubtable = tbinfo;
    4751         686 :         if (PQgetisnull(res, i, i_prrelqual))
    4752         392 :             pubrinfo[j].pubrelqual = NULL;
    4753             :         else
    4754         294 :             pubrinfo[j].pubrelqual = pg_strdup(PQgetvalue(res, i, i_prrelqual));
    4755             : 
    4756         686 :         if (!PQgetisnull(res, i, i_prattrs))
    4757             :         {
    4758             :             char      **attnames;
    4759             :             int         nattnames;
    4760             :             PQExpBuffer attribs;
    4761             : 
    4762         196 :             if (!parsePGArray(PQgetvalue(res, i, i_prattrs),
    4763             :                               &attnames, &nattnames))
    4764           0 :                 pg_fatal("could not parse %s array", "prattrs");
    4765         196 :             attribs = createPQExpBuffer();
    4766         588 :             for (int k = 0; k < nattnames; k++)
    4767             :             {
    4768         392 :                 if (k > 0)
    4769         196 :                     appendPQExpBufferStr(attribs, ", ");
    4770             : 
    4771         392 :                 appendPQExpBufferStr(attribs, fmtId(attnames[k]));
    4772             :             }
    4773         196 :             pubrinfo[j].pubrattrs = attribs->data;
    4774         196 :             free(attribs);      /* but not attribs->data */
    4775         196 :             free(attnames);
    4776             :         }
    4777             :         else
    4778         490 :             pubrinfo[j].pubrattrs = NULL;
    4779             : 
    4780             :         /* Decide whether we want to dump it */
    4781         686 :         selectDumpablePublicationObject(&(pubrinfo[j].dobj), fout);
    4782             : 
    4783         686 :         j++;
    4784             :     }
    4785             : 
    4786         468 :     PQclear(res);
    4787         468 :     destroyPQExpBuffer(query);
    4788             : }
    4789             : 
    4790             : /*
    4791             :  * dumpPublicationNamespace
    4792             :  *    dump the definition of the given publication schema mapping.
    4793             :  */
    4794             : static void
    4795         164 : dumpPublicationNamespace(Archive *fout, const PublicationSchemaInfo *pubsinfo)
    4796             : {
    4797         164 :     DumpOptions *dopt = fout->dopt;
    4798         164 :     NamespaceInfo *schemainfo = pubsinfo->pubschema;
    4799         164 :     PublicationInfo *pubinfo = pubsinfo->publication;
    4800             :     PQExpBuffer query;
    4801             :     char       *tag;
    4802             : 
    4803             :     /* Do nothing if not dumping schema */
    4804         164 :     if (!dopt->dumpSchema)
    4805          24 :         return;
    4806             : 
    4807         140 :     tag = psprintf("%s %s", pubinfo->dobj.name, schemainfo->dobj.name);
    4808             : 
    4809         140 :     query = createPQExpBuffer();
    4810             : 
    4811         140 :     appendPQExpBuffer(query, "ALTER PUBLICATION %s ", fmtId(pubinfo->dobj.name));
    4812         140 :     appendPQExpBuffer(query, "ADD TABLES IN SCHEMA %s;\n", fmtId(schemainfo->dobj.name));
    4813             : 
    4814             :     /*
    4815             :      * There is no point in creating drop query as the drop is done by schema
    4816             :      * drop.
    4817             :      */
    4818         140 :     if (pubsinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    4819         140 :         ArchiveEntry(fout, pubsinfo->dobj.catId, pubsinfo->dobj.dumpId,
    4820         140 :                      ARCHIVE_OPTS(.tag = tag,
    4821             :                                   .namespace = schemainfo->dobj.name,
    4822             :                                   .owner = pubinfo->rolname,
    4823             :                                   .description = "PUBLICATION TABLES IN SCHEMA",
    4824             :                                   .section = SECTION_POST_DATA,
    4825             :                                   .createStmt = query->data));
    4826             : 
    4827             :     /* These objects can't currently have comments or seclabels */
    4828             : 
    4829         140 :     free(tag);
    4830         140 :     destroyPQExpBuffer(query);
    4831             : }
    4832             : 
    4833             : /*
    4834             :  * dumpPublicationTable
    4835             :  *    dump the definition of the given publication table mapping
    4836             :  */
    4837             : static void
    4838         574 : dumpPublicationTable(Archive *fout, const PublicationRelInfo *pubrinfo)
    4839             : {
    4840         574 :     DumpOptions *dopt = fout->dopt;
    4841         574 :     PublicationInfo *pubinfo = pubrinfo->publication;
    4842         574 :     TableInfo  *tbinfo = pubrinfo->pubtable;
    4843             :     PQExpBuffer query;
    4844             :     char       *tag;
    4845             : 
    4846             :     /* Do nothing if not dumping schema */
    4847         574 :     if (!dopt->dumpSchema)
    4848          84 :         return;
    4849             : 
    4850         490 :     tag = psprintf("%s %s", pubinfo->dobj.name, tbinfo->dobj.name);
    4851             : 
    4852         490 :     query = createPQExpBuffer();
    4853             : 
    4854         490 :     appendPQExpBuffer(query, "ALTER PUBLICATION %s ADD TABLE ONLY",
    4855         490 :                       fmtId(pubinfo->dobj.name));
    4856         490 :     appendPQExpBuffer(query, " %s",
    4857         490 :                       fmtQualifiedDumpable(tbinfo));
    4858             : 
    4859         490 :     if (pubrinfo->pubrattrs)
    4860         140 :         appendPQExpBuffer(query, " (%s)", pubrinfo->pubrattrs);
    4861             : 
    4862         490 :     if (pubrinfo->pubrelqual)
    4863             :     {
    4864             :         /*
    4865             :          * It's necessary to add parentheses around the expression because
    4866             :          * pg_get_expr won't supply the parentheses for things like WHERE
    4867             :          * TRUE.
    4868             :          */
    4869         210 :         appendPQExpBuffer(query, " WHERE (%s)", pubrinfo->pubrelqual);
    4870             :     }
    4871         490 :     appendPQExpBufferStr(query, ";\n");
    4872             : 
    4873             :     /*
    4874             :      * There is no point in creating a drop query as the drop is done by table
    4875             :      * drop.  (If you think to change this, see also _printTocEntry().)
    4876             :      * Although this object doesn't really have ownership as such, set the
    4877             :      * owner field anyway to ensure that the command is run by the correct
    4878             :      * role at restore time.
    4879             :      */
    4880         490 :     if (pubrinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    4881         490 :         ArchiveEntry(fout, pubrinfo->dobj.catId, pubrinfo->dobj.dumpId,
    4882         490 :                      ARCHIVE_OPTS(.tag = tag,
    4883             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
    4884             :                                   .owner = pubinfo->rolname,
    4885             :                                   .description = "PUBLICATION TABLE",
    4886             :                                   .section = SECTION_POST_DATA,
    4887             :                                   .createStmt = query->data));
    4888             : 
    4889             :     /* These objects can't currently have comments or seclabels */
    4890             : 
    4891         490 :     free(tag);
    4892         490 :     destroyPQExpBuffer(query);
    4893             : }
    4894             : 
    4895             : /*
    4896             :  * Is the currently connected user a superuser?
    4897             :  */
    4898             : static bool
    4899         468 : is_superuser(Archive *fout)
    4900             : {
    4901         468 :     ArchiveHandle *AH = (ArchiveHandle *) fout;
    4902             :     const char *val;
    4903             : 
    4904         468 :     val = PQparameterStatus(AH->connection, "is_superuser");
    4905             : 
    4906         468 :     if (val && strcmp(val, "on") == 0)
    4907         462 :         return true;
    4908             : 
    4909           6 :     return false;
    4910             : }
    4911             : 
    4912             : /*
    4913             :  * Set the given value to restrict_nonsystem_relation_kind value. Since
    4914             :  * restrict_nonsystem_relation_kind is introduced in minor version releases,
    4915             :  * the setting query is effective only where available.
    4916             :  */
    4917             : static void
    4918         540 : set_restrict_relation_kind(Archive *AH, const char *value)
    4919             : {
    4920         540 :     PQExpBuffer query = createPQExpBuffer();
    4921             :     PGresult   *res;
    4922             : 
    4923         540 :     appendPQExpBuffer(query,
    4924             :                       "SELECT set_config(name, '%s', false) "
    4925             :                       "FROM pg_settings "
    4926             :                       "WHERE name = 'restrict_nonsystem_relation_kind'",
    4927             :                       value);
    4928         540 :     res = ExecuteSqlQuery(AH, query->data, PGRES_TUPLES_OK);
    4929             : 
    4930         540 :     PQclear(res);
    4931         540 :     destroyPQExpBuffer(query);
    4932         540 : }
    4933             : 
    4934             : /*
    4935             :  * getSubscriptions
    4936             :  *    get information about subscriptions
    4937             :  */
    4938             : void
    4939         468 : getSubscriptions(Archive *fout)
    4940             : {
    4941         468 :     DumpOptions *dopt = fout->dopt;
    4942             :     PQExpBuffer query;
    4943             :     PGresult   *res;
    4944             :     SubscriptionInfo *subinfo;
    4945             :     int         i_tableoid;
    4946             :     int         i_oid;
    4947             :     int         i_subname;
    4948             :     int         i_subowner;
    4949             :     int         i_subbinary;
    4950             :     int         i_substream;
    4951             :     int         i_subtwophasestate;
    4952             :     int         i_subdisableonerr;
    4953             :     int         i_subpasswordrequired;
    4954             :     int         i_subrunasowner;
    4955             :     int         i_subconninfo;
    4956             :     int         i_subslotname;
    4957             :     int         i_subsynccommit;
    4958             :     int         i_subpublications;
    4959             :     int         i_suborigin;
    4960             :     int         i_suboriginremotelsn;
    4961             :     int         i_subenabled;
    4962             :     int         i_subfailover;
    4963             :     int         i,
    4964             :                 ntups;
    4965             : 
    4966         468 :     if (dopt->no_subscriptions || fout->remoteVersion < 100000)
    4967           0 :         return;
    4968             : 
    4969         468 :     if (!is_superuser(fout))
    4970             :     {
    4971             :         int         n;
    4972             : 
    4973           6 :         res = ExecuteSqlQuery(fout,
    4974             :                               "SELECT count(*) FROM pg_subscription "
    4975             :                               "WHERE subdbid = (SELECT oid FROM pg_database"
    4976             :                               "                 WHERE datname = current_database())",
    4977             :                               PGRES_TUPLES_OK);
    4978           6 :         n = atoi(PQgetvalue(res, 0, 0));
    4979           6 :         if (n > 0)
    4980           4 :             pg_log_warning("subscriptions not dumped because current user is not a superuser");
    4981           6 :         PQclear(res);
    4982           6 :         return;
    4983             :     }
    4984             : 
    4985         462 :     query = createPQExpBuffer();
    4986             : 
    4987             :     /* Get the subscriptions in current database. */
    4988         462 :     appendPQExpBufferStr(query,
    4989             :                          "SELECT s.tableoid, s.oid, s.subname,\n"
    4990             :                          " s.subowner,\n"
    4991             :                          " s.subconninfo, s.subslotname, s.subsynccommit,\n"
    4992             :                          " s.subpublications,\n");
    4993             : 
    4994         462 :     if (fout->remoteVersion >= 140000)
    4995         462 :         appendPQExpBufferStr(query, " s.subbinary,\n");
    4996             :     else
    4997           0 :         appendPQExpBufferStr(query, " false AS subbinary,\n");
    4998             : 
    4999         462 :     if (fout->remoteVersion >= 140000)
    5000         462 :         appendPQExpBufferStr(query, " s.substream,\n");
    5001             :     else
    5002           0 :         appendPQExpBufferStr(query, " 'f' AS substream,\n");
    5003             : 
    5004         462 :     if (fout->remoteVersion >= 150000)
    5005         462 :         appendPQExpBufferStr(query,
    5006             :                              " s.subtwophasestate,\n"
    5007             :                              " s.subdisableonerr,\n");
    5008             :     else
    5009           0 :         appendPQExpBuffer(query,
    5010             :                           " '%c' AS subtwophasestate,\n"
    5011             :                           " false AS subdisableonerr,\n",
    5012             :                           LOGICALREP_TWOPHASE_STATE_DISABLED);
    5013             : 
    5014         462 :     if (fout->remoteVersion >= 160000)
    5015         462 :         appendPQExpBufferStr(query,
    5016             :                              " s.subpasswordrequired,\n"
    5017             :                              " s.subrunasowner,\n"
    5018             :                              " s.suborigin,\n");
    5019             :     else
    5020           0 :         appendPQExpBuffer(query,
    5021             :                           " 't' AS subpasswordrequired,\n"
    5022             :                           " 't' AS subrunasowner,\n"
    5023             :                           " '%s' AS suborigin,\n",
    5024             :                           LOGICALREP_ORIGIN_ANY);
    5025             : 
    5026         462 :     if (dopt->binary_upgrade && fout->remoteVersion >= 170000)
    5027          62 :         appendPQExpBufferStr(query, " o.remote_lsn AS suboriginremotelsn,\n"
    5028             :                              " s.subenabled,\n");
    5029             :     else
    5030         400 :         appendPQExpBufferStr(query, " NULL AS suboriginremotelsn,\n"
    5031             :                              " false AS subenabled,\n");
    5032             : 
    5033         462 :     if (fout->remoteVersion >= 170000)
    5034         462 :         appendPQExpBufferStr(query,
    5035             :                              " s.subfailover\n");
    5036             :     else
    5037           0 :         appendPQExpBufferStr(query,
    5038             :                              " false AS subfailover\n");
    5039             : 
    5040         462 :     appendPQExpBufferStr(query,
    5041             :                          "FROM pg_subscription s\n");
    5042             : 
    5043         462 :     if (dopt->binary_upgrade && fout->remoteVersion >= 170000)
    5044          62 :         appendPQExpBufferStr(query,
    5045             :                              "LEFT JOIN pg_catalog.pg_replication_origin_status o \n"
    5046             :                              "    ON o.external_id = 'pg_' || s.oid::text \n");
    5047             : 
    5048         462 :     appendPQExpBufferStr(query,
    5049             :                          "WHERE s.subdbid = (SELECT oid FROM pg_database\n"
    5050             :                          "                   WHERE datname = current_database())");
    5051             : 
    5052         462 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    5053             : 
    5054         462 :     ntups = PQntuples(res);
    5055             : 
    5056             :     /*
    5057             :      * Get subscription fields. We don't include subskiplsn in the dump as
    5058             :      * after restoring the dump this value may no longer be relevant.
    5059             :      */
    5060         462 :     i_tableoid = PQfnumber(res, "tableoid");
    5061         462 :     i_oid = PQfnumber(res, "oid");
    5062         462 :     i_subname = PQfnumber(res, "subname");
    5063         462 :     i_subowner = PQfnumber(res, "subowner");
    5064         462 :     i_subenabled = PQfnumber(res, "subenabled");
    5065         462 :     i_subbinary = PQfnumber(res, "subbinary");
    5066         462 :     i_substream = PQfnumber(res, "substream");
    5067         462 :     i_subtwophasestate = PQfnumber(res, "subtwophasestate");
    5068         462 :     i_subdisableonerr = PQfnumber(res, "subdisableonerr");
    5069         462 :     i_subpasswordrequired = PQfnumber(res, "subpasswordrequired");
    5070         462 :     i_subrunasowner = PQfnumber(res, "subrunasowner");
    5071         462 :     i_subfailover = PQfnumber(res, "subfailover");
    5072         462 :     i_subconninfo = PQfnumber(res, "subconninfo");
    5073         462 :     i_subslotname = PQfnumber(res, "subslotname");
    5074         462 :     i_subsynccommit = PQfnumber(res, "subsynccommit");
    5075         462 :     i_subpublications = PQfnumber(res, "subpublications");
    5076         462 :     i_suborigin = PQfnumber(res, "suborigin");
    5077         462 :     i_suboriginremotelsn = PQfnumber(res, "suboriginremotelsn");
    5078             : 
    5079         462 :     subinfo = pg_malloc(ntups * sizeof(SubscriptionInfo));
    5080             : 
    5081         748 :     for (i = 0; i < ntups; i++)
    5082             :     {
    5083         286 :         subinfo[i].dobj.objType = DO_SUBSCRIPTION;
    5084         286 :         subinfo[i].dobj.catId.tableoid =
    5085         286 :             atooid(PQgetvalue(res, i, i_tableoid));
    5086         286 :         subinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    5087         286 :         AssignDumpId(&subinfo[i].dobj);
    5088         286 :         subinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_subname));
    5089         286 :         subinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_subowner));
    5090             : 
    5091         286 :         subinfo[i].subenabled =
    5092         286 :             (strcmp(PQgetvalue(res, i, i_subenabled), "t") == 0);
    5093         286 :         subinfo[i].subbinary =
    5094         286 :             (strcmp(PQgetvalue(res, i, i_subbinary), "t") == 0);
    5095         286 :         subinfo[i].substream = *(PQgetvalue(res, i, i_substream));
    5096         286 :         subinfo[i].subtwophasestate = *(PQgetvalue(res, i, i_subtwophasestate));
    5097         286 :         subinfo[i].subdisableonerr =
    5098         286 :             (strcmp(PQgetvalue(res, i, i_subdisableonerr), "t") == 0);
    5099         286 :         subinfo[i].subpasswordrequired =
    5100         286 :             (strcmp(PQgetvalue(res, i, i_subpasswordrequired), "t") == 0);
    5101         286 :         subinfo[i].subrunasowner =
    5102         286 :             (strcmp(PQgetvalue(res, i, i_subrunasowner), "t") == 0);
    5103         286 :         subinfo[i].subfailover =
    5104         286 :             (strcmp(PQgetvalue(res, i, i_subfailover), "t") == 0);
    5105         572 :         subinfo[i].subconninfo =
    5106         286 :             pg_strdup(PQgetvalue(res, i, i_subconninfo));
    5107         286 :         if (PQgetisnull(res, i, i_subslotname))
    5108           0 :             subinfo[i].subslotname = NULL;
    5109             :         else
    5110         286 :             subinfo[i].subslotname =
    5111         286 :                 pg_strdup(PQgetvalue(res, i, i_subslotname));
    5112         572 :         subinfo[i].subsynccommit =
    5113         286 :             pg_strdup(PQgetvalue(res, i, i_subsynccommit));
    5114         572 :         subinfo[i].subpublications =
    5115         286 :             pg_strdup(PQgetvalue(res, i, i_subpublications));
    5116         286 :         subinfo[i].suborigin = pg_strdup(PQgetvalue(res, i, i_suborigin));
    5117         286 :         if (PQgetisnull(res, i, i_suboriginremotelsn))
    5118         284 :             subinfo[i].suboriginremotelsn = NULL;
    5119             :         else
    5120           2 :             subinfo[i].suboriginremotelsn =
    5121           2 :                 pg_strdup(PQgetvalue(res, i, i_suboriginremotelsn));
    5122             : 
    5123             :         /* Decide whether we want to dump it */
    5124         286 :         selectDumpableObject(&(subinfo[i].dobj), fout);
    5125             :     }
    5126         462 :     PQclear(res);
    5127             : 
    5128         462 :     destroyPQExpBuffer(query);
    5129             : }
    5130             : 
    5131             : /*
    5132             :  * getSubscriptionTables
    5133             :  *    Get information about subscription membership for dumpable tables. This
    5134             :  *    will be used only in binary-upgrade mode for PG17 or later versions.
    5135             :  */
    5136             : void
    5137         468 : getSubscriptionTables(Archive *fout)
    5138             : {
    5139         468 :     DumpOptions *dopt = fout->dopt;
    5140         468 :     SubscriptionInfo *subinfo = NULL;
    5141             :     SubRelInfo *subrinfo;
    5142             :     PGresult   *res;
    5143             :     int         i_srsubid;
    5144             :     int         i_srrelid;
    5145             :     int         i_srsubstate;
    5146             :     int         i_srsublsn;
    5147             :     int         ntups;
    5148         468 :     Oid         last_srsubid = InvalidOid;
    5149             : 
    5150         468 :     if (dopt->no_subscriptions || !dopt->binary_upgrade ||
    5151          62 :         fout->remoteVersion < 170000)
    5152         406 :         return;
    5153             : 
    5154          62 :     res = ExecuteSqlQuery(fout,
    5155             :                           "SELECT srsubid, srrelid, srsubstate, srsublsn "
    5156             :                           "FROM pg_catalog.pg_subscription_rel "
    5157             :                           "ORDER BY srsubid",
    5158             :                           PGRES_TUPLES_OK);
    5159          62 :     ntups = PQntuples(res);
    5160          62 :     if (ntups == 0)
    5161          60 :         goto cleanup;
    5162             : 
    5163             :     /* Get pg_subscription_rel attributes */
    5164           2 :     i_srsubid = PQfnumber(res, "srsubid");
    5165           2 :     i_srrelid = PQfnumber(res, "srrelid");
    5166           2 :     i_srsubstate = PQfnumber(res, "srsubstate");
    5167           2 :     i_srsublsn = PQfnumber(res, "srsublsn");
    5168             : 
    5169           2 :     subrinfo = pg_malloc(ntups * sizeof(SubRelInfo));
    5170           6 :     for (int i = 0; i < ntups; i++)
    5171             :     {
    5172           4 :         Oid         cur_srsubid = atooid(PQgetvalue(res, i, i_srsubid));
    5173           4 :         Oid         relid = atooid(PQgetvalue(res, i, i_srrelid));
    5174             :         TableInfo  *tblinfo;
    5175             : 
    5176             :         /*
    5177             :          * If we switched to a new subscription, check if the subscription
    5178             :          * exists.
    5179             :          */
    5180           4 :         if (cur_srsubid != last_srsubid)
    5181             :         {
    5182           4 :             subinfo = findSubscriptionByOid(cur_srsubid);
    5183           4 :             if (subinfo == NULL)
    5184           0 :                 pg_fatal("subscription with OID %u does not exist", cur_srsubid);
    5185             : 
    5186           4 :             last_srsubid = cur_srsubid;
    5187             :         }
    5188             : 
    5189           4 :         tblinfo = findTableByOid(relid);
    5190           4 :         if (tblinfo == NULL)
    5191           0 :             pg_fatal("failed sanity check, table with OID %u not found",
    5192             :                      relid);
    5193             : 
    5194             :         /* OK, make a DumpableObject for this relationship */
    5195           4 :         subrinfo[i].dobj.objType = DO_SUBSCRIPTION_REL;
    5196           4 :         subrinfo[i].dobj.catId.tableoid = relid;
    5197           4 :         subrinfo[i].dobj.catId.oid = cur_srsubid;
    5198           4 :         AssignDumpId(&subrinfo[i].dobj);
    5199           4 :         subrinfo[i].dobj.name = pg_strdup(subinfo->dobj.name);
    5200           4 :         subrinfo[i].tblinfo = tblinfo;
    5201           4 :         subrinfo[i].srsubstate = PQgetvalue(res, i, i_srsubstate)[0];
    5202           4 :         if (PQgetisnull(res, i, i_srsublsn))
    5203           2 :             subrinfo[i].srsublsn = NULL;
    5204             :         else
    5205           2 :             subrinfo[i].srsublsn = pg_strdup(PQgetvalue(res, i, i_srsublsn));
    5206             : 
    5207           4 :         subrinfo[i].subinfo = subinfo;
    5208             : 
    5209             :         /* Decide whether we want to dump it */
    5210           4 :         selectDumpableObject(&(subrinfo[i].dobj), fout);
    5211             :     }
    5212             : 
    5213           2 : cleanup:
    5214          62 :     PQclear(res);
    5215             : }
    5216             : 
    5217             : /*
    5218             :  * dumpSubscriptionTable
    5219             :  *    Dump the definition of the given subscription table mapping. This will be
    5220             :  *    used only in binary-upgrade mode for PG17 or later versions.
    5221             :  */
    5222             : static void
    5223           4 : dumpSubscriptionTable(Archive *fout, const SubRelInfo *subrinfo)
    5224             : {
    5225           4 :     DumpOptions *dopt = fout->dopt;
    5226           4 :     SubscriptionInfo *subinfo = subrinfo->subinfo;
    5227             :     PQExpBuffer query;
    5228             :     char       *tag;
    5229             : 
    5230             :     /* Do nothing if not dumping schema */
    5231           4 :     if (!dopt->dumpSchema)
    5232           0 :         return;
    5233             : 
    5234             :     Assert(fout->dopt->binary_upgrade && fout->remoteVersion >= 170000);
    5235             : 
    5236           4 :     tag = psprintf("%s %s", subinfo->dobj.name, subrinfo->dobj.name);
    5237             : 
    5238           4 :     query = createPQExpBuffer();
    5239             : 
    5240           4 :     if (subinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    5241             :     {
    5242             :         /*
    5243             :          * binary_upgrade_add_sub_rel_state will add the subscription relation
    5244             :          * to pg_subscription_rel table. This will be used only in
    5245             :          * binary-upgrade mode.
    5246             :          */
    5247           4 :         appendPQExpBufferStr(query,
    5248             :                              "\n-- For binary upgrade, must preserve the subscriber table.\n");
    5249           4 :         appendPQExpBufferStr(query,
    5250             :                              "SELECT pg_catalog.binary_upgrade_add_sub_rel_state(");
    5251           4 :         appendStringLiteralAH(query, subrinfo->dobj.name, fout);
    5252           4 :         appendPQExpBuffer(query,
    5253             :                           ", %u, '%c'",
    5254           4 :                           subrinfo->tblinfo->dobj.catId.oid,
    5255           4 :                           subrinfo->srsubstate);
    5256             : 
    5257           4 :         if (subrinfo->srsublsn && subrinfo->srsublsn[0] != '\0')
    5258           2 :             appendPQExpBuffer(query, ", '%s'", subrinfo->srsublsn);
    5259             :         else
    5260           2 :             appendPQExpBufferStr(query, ", NULL");
    5261             : 
    5262           4 :         appendPQExpBufferStr(query, ");\n");
    5263             :     }
    5264             : 
    5265             :     /*
    5266             :      * There is no point in creating a drop query as the drop is done by table
    5267             :      * drop.  (If you think to change this, see also _printTocEntry().)
    5268             :      * Although this object doesn't really have ownership as such, set the
    5269             :      * owner field anyway to ensure that the command is run by the correct
    5270             :      * role at restore time.
    5271             :      */
    5272           4 :     if (subrinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    5273           4 :         ArchiveEntry(fout, subrinfo->dobj.catId, subrinfo->dobj.dumpId,
    5274           4 :                      ARCHIVE_OPTS(.tag = tag,
    5275             :                                   .namespace = subrinfo->tblinfo->dobj.namespace->dobj.name,
    5276             :                                   .owner = subinfo->rolname,
    5277             :                                   .description = "SUBSCRIPTION TABLE",
    5278             :                                   .section = SECTION_POST_DATA,
    5279             :                                   .createStmt = query->data));
    5280             : 
    5281             :     /* These objects can't currently have comments or seclabels */
    5282             : 
    5283           4 :     free(tag);
    5284           4 :     destroyPQExpBuffer(query);
    5285             : }
    5286             : 
    5287             : /*
    5288             :  * dumpSubscription
    5289             :  *    dump the definition of the given subscription
    5290             :  */
    5291             : static void
    5292         250 : dumpSubscription(Archive *fout, const SubscriptionInfo *subinfo)
    5293             : {
    5294         250 :     DumpOptions *dopt = fout->dopt;
    5295             :     PQExpBuffer delq;
    5296             :     PQExpBuffer query;
    5297             :     PQExpBuffer publications;
    5298             :     char       *qsubname;
    5299         250 :     char      **pubnames = NULL;
    5300         250 :     int         npubnames = 0;
    5301             :     int         i;
    5302             : 
    5303             :     /* Do nothing if not dumping schema */
    5304         250 :     if (!dopt->dumpSchema)
    5305          36 :         return;
    5306             : 
    5307         214 :     delq = createPQExpBuffer();
    5308         214 :     query = createPQExpBuffer();
    5309             : 
    5310         214 :     qsubname = pg_strdup(fmtId(subinfo->dobj.name));
    5311             : 
    5312         214 :     appendPQExpBuffer(delq, "DROP SUBSCRIPTION %s;\n",
    5313             :                       qsubname);
    5314             : 
    5315         214 :     appendPQExpBuffer(query, "CREATE SUBSCRIPTION %s CONNECTION ",
    5316             :                       qsubname);
    5317         214 :     appendStringLiteralAH(query, subinfo->subconninfo, fout);
    5318             : 
    5319             :     /* Build list of quoted publications and append them to query. */
    5320         214 :     if (!parsePGArray(subinfo->subpublications, &pubnames, &npubnames))
    5321           0 :         pg_fatal("could not parse %s array", "subpublications");
    5322             : 
    5323         214 :     publications = createPQExpBuffer();
    5324         428 :     for (i = 0; i < npubnames; i++)
    5325             :     {
    5326         214 :         if (i > 0)
    5327           0 :             appendPQExpBufferStr(publications, ", ");
    5328             : 
    5329         214 :         appendPQExpBufferStr(publications, fmtId(pubnames[i]));
    5330             :     }
    5331             : 
    5332         214 :     appendPQExpBuffer(query, " PUBLICATION %s WITH (connect = false, slot_name = ", publications->data);
    5333         214 :     if (subinfo->subslotname)
    5334         214 :         appendStringLiteralAH(query, subinfo->subslotname, fout);
    5335             :     else
    5336           0 :         appendPQExpBufferStr(query, "NONE");
    5337             : 
    5338         214 :     if (subinfo->subbinary)
    5339           0 :         appendPQExpBufferStr(query, ", binary = true");
    5340             : 
    5341         214 :     if (subinfo->substream == LOGICALREP_STREAM_ON)
    5342          70 :         appendPQExpBufferStr(query, ", streaming = on");
    5343         144 :     else if (subinfo->substream == LOGICALREP_STREAM_PARALLEL)
    5344          74 :         appendPQExpBufferStr(query, ", streaming = parallel");
    5345             :     else
    5346          70 :         appendPQExpBufferStr(query, ", streaming = off");
    5347             : 
    5348         214 :     if (subinfo->subtwophasestate != LOGICALREP_TWOPHASE_STATE_DISABLED)
    5349           0 :         appendPQExpBufferStr(query, ", two_phase = on");
    5350             : 
    5351         214 :     if (subinfo->subdisableonerr)
    5352           0 :         appendPQExpBufferStr(query, ", disable_on_error = true");
    5353             : 
    5354         214 :     if (!subinfo->subpasswordrequired)
    5355           0 :         appendPQExpBufferStr(query, ", password_required = false");
    5356             : 
    5357         214 :     if (subinfo->subrunasowner)
    5358           0 :         appendPQExpBufferStr(query, ", run_as_owner = true");
    5359             : 
    5360         214 :     if (subinfo->subfailover)
    5361           2 :         appendPQExpBufferStr(query, ", failover = true");
    5362             : 
    5363         214 :     if (strcmp(subinfo->subsynccommit, "off") != 0)
    5364           0 :         appendPQExpBuffer(query, ", synchronous_commit = %s", fmtId(subinfo->subsynccommit));
    5365             : 
    5366         214 :     if (pg_strcasecmp(subinfo->suborigin, LOGICALREP_ORIGIN_ANY) != 0)
    5367          70 :         appendPQExpBuffer(query, ", origin = %s", subinfo->suborigin);
    5368             : 
    5369         214 :     appendPQExpBufferStr(query, ");\n");
    5370             : 
    5371             :     /*
    5372             :      * In binary-upgrade mode, we allow the replication to continue after the
    5373             :      * upgrade.
    5374             :      */
    5375         214 :     if (dopt->binary_upgrade && fout->remoteVersion >= 170000)
    5376             :     {
    5377          10 :         if (subinfo->suboriginremotelsn)
    5378             :         {
    5379             :             /*
    5380             :              * Preserve the remote_lsn for the subscriber's replication
    5381             :              * origin. This value is required to start the replication from
    5382             :              * the position before the upgrade. This value will be stale if
    5383             :              * the publisher gets upgraded before the subscriber node.
    5384             :              * However, this shouldn't be a problem as the upgrade of the
    5385             :              * publisher ensures that all the transactions were replicated
    5386             :              * before upgrading it.
    5387             :              */
    5388           2 :             appendPQExpBufferStr(query,
    5389             :                                  "\n-- For binary upgrade, must preserve the remote_lsn for the subscriber's replication origin.\n");
    5390           2 :             appendPQExpBufferStr(query,
    5391             :                                  "SELECT pg_catalog.binary_upgrade_replorigin_advance(");
    5392           2 :             appendStringLiteralAH(query, subinfo->dobj.name, fout);
    5393           2 :             appendPQExpBuffer(query, ", '%s');\n", subinfo->suboriginremotelsn);
    5394             :         }
    5395             : 
    5396          10 :         if (subinfo->subenabled)
    5397             :         {
    5398             :             /*
    5399             :              * Enable the subscription to allow the replication to continue
    5400             :              * after the upgrade.
    5401             :              */
    5402           2 :             appendPQExpBufferStr(query,
    5403             :                                  "\n-- For binary upgrade, must preserve the subscriber's running state.\n");
    5404           2 :             appendPQExpBuffer(query, "ALTER SUBSCRIPTION %s ENABLE;\n", qsubname);
    5405             :         }
    5406             :     }
    5407             : 
    5408         214 :     if (subinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
    5409         214 :         ArchiveEntry(fout, subinfo->dobj.catId, subinfo->dobj.dumpId,
    5410         214 :                      ARCHIVE_OPTS(.tag = subinfo->dobj.name,
    5411             :                                   .owner = subinfo->rolname,
    5412             :                                   .description = "SUBSCRIPTION",
    5413             :                                   .section = SECTION_POST_DATA,
    5414             :                                   .createStmt = query->data,
    5415             :                                   .dropStmt = delq->data));
    5416             : 
    5417         214 :     if (subinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
    5418          70 :         dumpComment(fout, "SUBSCRIPTION", qsubname,
    5419             :                     NULL, subinfo->rolname,
    5420             :                     subinfo->dobj.catId, 0, subinfo->dobj.dumpId);
    5421             : 
    5422         214 :     if (subinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
    5423           0 :         dumpSecLabel(fout, "SUBSCRIPTION", qsubname,
    5424             :                      NULL, subinfo->rolname,
    5425             :                      subinfo->dobj.catId, 0, subinfo->dobj.dumpId);
    5426             : 
    5427         214 :     destroyPQExpBuffer(publications);
    5428         214 :     free(pubnames);
    5429             : 
    5430         214 :     destroyPQExpBuffer(delq);
    5431         214 :     destroyPQExpBuffer(query);
    5432         214 :     free(qsubname);
    5433             : }
    5434             : 
    5435             : /*
    5436             :  * Given a "create query", append as many ALTER ... DEPENDS ON EXTENSION as
    5437             :  * the object needs.
    5438             :  */
    5439             : static void
    5440       14218 : append_depends_on_extension(Archive *fout,
    5441             :                             PQExpBuffer create,
    5442             :                             const DumpableObject *dobj,
    5443             :                             const char *catalog,
    5444             :                             const char *keyword,
    5445             :                             const char *objname)
    5446             : {
    5447       14218 :     if (dobj->depends_on_ext)
    5448             :     {
    5449             :         char       *nm;
    5450             :         PGresult   *res;
    5451             :         PQExpBuffer query;
    5452             :         int         ntups;
    5453             :         int         i_extname;
    5454             :         int         i;
    5455             : 
    5456             :         /* dodge fmtId() non-reentrancy */
    5457          84 :         nm = pg_strdup(objname);
    5458             : 
    5459          84 :         query = createPQExpBuffer();
    5460          84 :         appendPQExpBuffer(query,
    5461             :                           "SELECT e.extname "
    5462             :                           "FROM pg_catalog.pg_depend d, pg_catalog.pg_extension e "
    5463             :                           "WHERE d.refobjid = e.oid AND classid = '%s'::pg_catalog.regclass "
    5464             :                           "AND objid = '%u'::pg_catalog.oid AND deptype = 'x' "
    5465             :                           "AND refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass",
    5466             :                           catalog,
    5467             :                           dobj->catId.oid);
    5468          84 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    5469          84 :         ntups = PQntuples(res);
    5470          84 :         i_extname = PQfnumber(res, "extname");
    5471         168 :         for (i = 0; i < ntups; i++)
    5472             :         {
    5473          84 :             appendPQExpBuffer(create, "\nALTER %s %s DEPENDS ON EXTENSION %s;",
    5474             :                               keyword, nm,
    5475          84 :                               fmtId(PQgetvalue(res, i, i_extname)));
    5476             :         }
    5477             : 
    5478          84 :         PQclear(res);
    5479          84 :         destroyPQExpBuffer(query);
    5480          84 :         pg_free(nm);
    5481             :     }
    5482       14218 : }
    5483             : 
    5484             : static Oid
    5485           0 : get_next_possible_free_pg_type_oid(Archive *fout, PQExpBuffer upgrade_query)
    5486             : {
    5487             :     /*
    5488             :      * If the old version didn't assign an array type, but the new version
    5489             :      * does, we must select an unused type OID to assign.  This currently only
    5490             :      * happens for domains, when upgrading pre-v11 to v11 and up.
    5491             :      *
    5492             :      * Note: local state here is kind of ugly, but we must have some, since we
    5493             :      * mustn't choose the same unused OID more than once.
    5494             :      */
    5495             :     static Oid  next_possible_free_oid = FirstNormalObjectId;
    5496             :     PGresult   *res;
    5497             :     bool        is_dup;
    5498             : 
    5499             :     do
    5500             :     {
    5501           0 :         ++next_possible_free_oid;
    5502           0 :         printfPQExpBuffer(upgrade_query,
    5503             :                           "SELECT EXISTS(SELECT 1 "
    5504             :                           "FROM pg_catalog.pg_type "
    5505             :                           "WHERE oid = '%u'::pg_catalog.oid);",
    5506             :                           next_possible_free_oid);
    5507           0 :         res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);
    5508           0 :         is_dup = (PQgetvalue(res, 0, 0)[0] == 't');
    5509           0 :         PQclear(res);
    5510           0 :     } while (is_dup);
    5511             : 
    5512           0 :     return next_possible_free_oid;
    5513             : }
    5514             : 
    5515             : static void
    5516        1816 : binary_upgrade_set_type_oids_by_type_oid(Archive *fout,
    5517             :                                          PQExpBuffer upgrade_buffer,
    5518             :                                          Oid pg_type_oid,
    5519             :                                          bool force_array_type,
    5520             :                                          bool include_multirange_type)
    5521             : {
    5522        1816 :     PQExpBuffer upgrade_query = createPQExpBuffer();
    5523             :     PGresult   *res;
    5524             :     Oid         pg_type_array_oid;
    5525             :     Oid         pg_type_multirange_oid;
    5526             :     Oid         pg_type_multirange_array_oid;
    5527             :     TypeInfo   *tinfo;
    5528             : 
    5529        1816 :     appendPQExpBufferStr(upgrade_buffer, "\n-- For binary upgrade, must preserve pg_type oid\n");
    5530        1816 :     appendPQExpBuffer(upgrade_buffer,
    5531             :                       "SELECT pg_catalog.binary_upgrade_set_next_pg_type_oid('%u'::pg_catalog.oid);\n\n",
    5532             :                       pg_type_oid);
    5533             : 
    5534        1816 :     tinfo = findTypeByOid(pg_type_oid);
    5535        1816 :     if (tinfo)
    5536        1816 :         pg_type_array_oid = tinfo->typarray;
    5537             :     else
    5538           0 :         pg_type_array_oid = InvalidOid;
    5539             : 
    5540        1816 :     if (!OidIsValid(pg_type_array_oid) && force_array_type)
    5541           0 :         pg_type_array_oid = get_next_possible_free_pg_type_oid(fout, upgrade_query);
    5542             : 
    5543        1816 :     if (OidIsValid(pg_type_array_oid))
    5544             :     {
    5545        1812 :         appendPQExpBufferStr(upgrade_buffer,
    5546             :                              "\n-- For binary upgrade, must preserve pg_type array oid\n");
    5547        1812 :         appendPQExpBuffer(upgrade_buffer,
    5548             :                           "SELECT pg_catalog.binary_upgrade_set_next_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
    5549             :                           pg_type_array_oid);
    5550             :     }
    5551             : 
    5552             :     /*
    5553             :      * Pre-set the multirange type oid and its own array type oid.
    5554             :      */
    5555        1816 :     if (include_multirange_type)
    5556             :     {
    5557          16 :         if (fout->remoteVersion >= 140000)
    5558             :         {
    5559          16 :             printfPQExpBuffer(upgrade_query,
    5560             :                               "SELECT t.oid, t.typarray "
    5561             :                               "FROM pg_catalog.pg_type t "
    5562             :                               "JOIN pg_catalog.pg_range r "
    5563             :                               "ON t.oid = r.rngmultitypid "
    5564             :                               "WHERE r.rngtypid = '%u'::pg_catalog.oid;",
    5565             :                               pg_type_oid);
    5566             : 
    5567          16 :             res = ExecuteSqlQueryForSingleRow(fout, upgrade_query->data);
    5568             : 
    5569          16 :             pg_type_multirange_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "oid")));
    5570          16 :             pg_type_multirange_array_oid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typarray")));
    5571             : 
    5572          16 :             PQclear(res);
    5573             :         }
    5574             :         else
    5575             :         {
    5576           0 :             pg_type_multirange_oid = get_next_possible_free_pg_type_oid(fout, upgrade_query);
    5577           0 :             pg_type_multirange_array_oid = get_next_possible_free_pg_type_oid(fout, upgrade_query);
    5578             :         }
    5579             : 
    5580          16 :         appendPQExpBufferStr(upgrade_buffer,
    5581             :                              "\n-- For binary upgrade, must preserve multirange pg_type oid\n");
    5582          16 :         appendPQExpBuffer(upgrade_buffer,
    5583             :                           "SELECT pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid('%u'::pg_catalog.oid);\n\n",
    5584             :                           pg_type_multirange_oid);
    5585          16 :         appendPQExpBufferStr(upgrade_buffer,
    5586             :                              "\n-- For binary upgrade, must preserve multirange pg_type array oid\n");
    5587          16 :         appendPQExpBuffer(upgrade_buffer,
    5588             :                           "SELECT pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid('%u'::pg_catalog.oid);\n\n",
    5589             :                           pg_type_multirange_array_oid);
    5590             :     }
    5591             : 
    5592        1816 :     destroyPQExpBuffer(upgrade_query);
    5593        1816 : }
    5594             : 
    5595             : static void
    5596        1670 : binary_upgrade_set_type_oids_by_rel(Archive *fout,
    5597             :                                     PQExpBuffer upgrade_buffer,
    5598             :                                     const TableInfo *tbinfo)
    5599             : {
    5600        1670 :     Oid         pg_type_oid = tbinfo->reltype;
    5601             : 
    5602        1670 :     if (OidIsValid(pg_type_oid))
    5603        1670 :         binary_upgrade_set_type_oids_by_type_oid(fout, upgrade_buffer,
    5604             :                                                  pg_type_oid, false, false);
    5605        1670 : }
    5606             : 
    5607             : /*
    5608             :  * bsearch() comparator for BinaryUpgradeClassOidItem
    5609             :  */
    5610             : static int
    5611       24042 : BinaryUpgradeClassOidItemCmp(const void *p1, const void *p2)
    5612             : {
    5613       24042 :     BinaryUpgradeClassOidItem v1 = *((const BinaryUpgradeClassOidItem *) p1);
    5614       24042 :     BinaryUpgradeClassOidItem v2 = *((const BinaryUpgradeClassOidItem *) p2);
    5615             : 
    5616       24042 :     return pg_cmp_u32(v1.oid, v2.oid);
    5617             : }
    5618             : 
    5619             : /*
    5620             :  * collectBinaryUpgradeClassOids
    5621             :  *
    5622             :  * Construct a table of pg_class information required for
    5623             :  * binary_upgrade_set_pg_class_oids().  The table is sorted by OID for speed in
    5624             :  * lookup.
    5625             :  */
    5626             : static void
    5627          62 : collectBinaryUpgradeClassOids(Archive *fout)
    5628             : {
    5629             :     PGresult   *res;
    5630             :     const char *query;
    5631             : 
    5632          62 :     query = "SELECT c.oid, c.relkind, c.relfilenode, c.reltoastrelid, "
    5633             :         "ct.relfilenode, i.indexrelid, cti.relfilenode "
    5634             :         "FROM pg_catalog.pg_class c LEFT JOIN pg_catalog.pg_index i "
    5635             :         "ON (c.reltoastrelid = i.indrelid AND i.indisvalid) "
    5636             :         "LEFT JOIN pg_catalog.pg_class ct ON (c.reltoastrelid = ct.oid) "
    5637             :         "LEFT JOIN pg_catalog.pg_class AS cti ON (i.indexrelid = cti.oid) "
    5638             :         "ORDER BY c.oid;";
    5639             : 
    5640          62 :     res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK);
    5641             : 
    5642          62 :     nbinaryUpgradeClassOids = PQntuples(res);
    5643          62 :     binaryUpgradeClassOids = (BinaryUpgradeClassOidItem *)
    5644          62 :         pg_malloc(nbinaryUpgradeClassOids * sizeof(BinaryUpgradeClassOidItem));
    5645             : 
    5646       29456 :     for (int i = 0; i < nbinaryUpgradeClassOids; i++)
    5647             :     {
    5648       29394 :         binaryUpgradeClassOids[i].oid = atooid(PQgetvalue(res, i, 0));
    5649       29394 :         binaryUpgradeClassOids[i].relkind = *PQgetvalue(res, i, 1);
    5650       29394 :         binaryUpgradeClassOids[i].relfilenumber = atooid(PQgetvalue(res, i, 2));
    5651       29394 :         binaryUpgradeClassOids[i].toast_oid = atooid(PQgetvalue(res, i, 3));
    5652       29394 :         binaryUpgradeClassOids[i].toast_relfilenumber = atooid(PQgetvalue(res, i, 4));
    5653       29394 :         binaryUpgradeClassOids[i].toast_index_oid = atooid(PQgetvalue(res, i, 5));
    5654       29394 :         binaryUpgradeClassOids[i].toast_index_relfilenumber = atooid(PQgetvalue(res, i, 6));
    5655             :     }
    5656             : 
    5657          62 :     PQclear(res);
    5658          62 : }
    5659             : 
    5660             : static void
    5661        2436 : binary_upgrade_set_pg_class_oids(Archive *fout,
    5662             :                                  PQExpBuffer upgrade_buffer, Oid pg_class_oid)
    5663             : {
    5664        2436 :     BinaryUpgradeClassOidItem key = {0};
    5665             :     BinaryUpgradeClassOidItem *entry;
    5666             : 
    5667             :     Assert(binaryUpgradeClassOids);
    5668             : 
    5669             :     /*
    5670             :      * Preserve the OID and relfilenumber of the table, table's index, table's
    5671             :      * toast table and toast table's index if any.
    5672             :      *
    5673             :      * One complexity is that the current table definition might not require
    5674             :      * the creation of a TOAST table, but the old database might have a TOAST
    5675             :      * table that was created earlier, before some wide columns were dropped.
    5676             :      * By setting the TOAST oid we force creation of the TOAST heap and index
    5677             :      * by the new backend, so we can copy the files during binary upgrade
    5678             :      * without worrying about this case.
    5679             :      */
    5680        2436 :     key.oid = pg_class_oid;
    5681        2436 :     entry = bsearch(&key, binaryUpgradeClassOids, nbinaryUpgradeClassOids,
    5682             :                     sizeof(BinaryUpgradeClassOidItem),
    5683             :                     BinaryUpgradeClassOidItemCmp);
    5684             : 
    5685        2436 :     appendPQExpBufferStr(upgrade_buffer,
    5686             :                          "\n-- For binary upgrade, must preserve pg_class oids and relfilenodes\n");
    5687             : 
    5688        2436 :     if (entry->relkind != RELKIND_INDEX &&
    5689        1888 :         entry->relkind != RELKIND_PARTITIONED_INDEX)
    5690             :     {
    5691        1838 :         appendPQExpBuffer(upgrade_buffer,
    5692             :                           "SELECT pg_catalog.binary_upgrade_set_next_heap_pg_class_oid('%u'::pg_catalog.oid);\n",
    5693             :                           pg_class_oid);
    5694             : 
    5695             :         /*
    5696             :          * Not every relation has storage. Also, in a pre-v12 database,
    5697             :          * partitioned tables have a relfilenumber, which should not be
    5698             :          * preserved when upgrading.
    5699             :          */
    5700        1838 :         if (RelFileNumberIsValid(entry->relfilenumber) &&
    5701        1518 :             entry->relkind != RELKIND_PARTITIONED_TABLE)
    5702        1518 :             appendPQExpBuffer(upgrade_buffer,
    5703             :                               "SELECT pg_catalog.binary_upgrade_set_next_heap_relfilenode('%u'::pg_catalog.oid);\n",
    5704             :                               entry->relfilenumber);
    5705             : 
    5706             :         /*
    5707             :          * In a pre-v12 database, partitioned tables might be marked as having
    5708             :          * toast tables, but we should ignore them if so.
    5709             :          */
    5710        1838 :         if (OidIsValid(entry->toast_oid) &&
    5711         552 :             entry->relkind != RELKIND_PARTITIONED_TABLE)
    5712             :         {
    5713         552 :             appendPQExpBuffer(upgrade_buffer,
    5714             :                               "SELECT pg_catalog.binary_upgrade_set_next_toast_pg_class_oid('%u'::pg_catalog.oid);\n",
    5715             :                               entry->toast_oid);
    5716         552 :             appendPQExpBuffer(upgrade_buffer,
    5717             :                               "SELECT pg_catalog.binary_upgrade_set_next_toast_relfilenode('%u'::pg_catalog.oid);\n",
    5718             :                               entry->toast_relfilenumber);
    5719             : 
    5720             :             /* every toast table has an index */
    5721         552 :             appendPQExpBuffer(upgrade_buffer,
    5722             :                               "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
    5723             :                               entry->toast_index_oid);
    5724         552 :             appendPQExpBuffer(upgrade_buffer,
    5725             :                               "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
    5726             :                               entry->toast_index_relfilenumber);
    5727             :         }
    5728             :     }
    5729             :     else
    5730             :     {
    5731             :         /* Preserve the OID and relfilenumber of the index */
    5732         598 :         appendPQExpBuffer(upgrade_buffer,
    5733             :                           "SELECT pg_catalog.binary_upgrade_set_next_index_pg_class_oid('%u'::pg_catalog.oid);\n",
    5734             :                           pg_class_oid);
    5735         598 :         appendPQExpBuffer(upgrade_buffer,
    5736             :                           "SELECT pg_catalog.binary_upgrade_set_next_index_relfilenode('%u'::pg_catalog.oid);\n",
    5737             :                           entry->relfilenumber);
    5738             :     }
    5739             : 
    5740        2436 :     appendPQExpBufferChar(upgrade_buffer, '\n');
    5741        2436 : }
    5742             : 
    5743             : /*
    5744             :  * If the DumpableObject is a member of an extension, add a suitable
    5745             :  * ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
    5746             :  *
    5747             :  * For somewhat historical reasons, objname should already be quoted,
    5748             :  * but not objnamespace (if any).
    5749             :  */
    5750             : static void
    5751        2900 : binary_upgrade_extension_member(PQExpBuffer upgrade_buffer,
    5752             :                                 const DumpableObject *dobj,
    5753             :                                 const char *objtype,
    5754             :                                 const char *objname,
    5755             :                                 const char *objnamespace)
    5756             : {
    5757        2900 :     DumpableObject *extobj = NULL;
    5758             :     int         i;
    5759             : 
    5760        2900 :     if (!dobj->ext_member)
    5761        2868 :         return;
    5762             : 
    5763             :     /*
    5764             :      * Find the parent extension.  We could avoid this search if we wanted to
    5765             :      * add a link field to DumpableObject, but the space costs of that would
    5766             :      * be considerable.  We assume that member objects could only have a
    5767             :      * direct dependency on their own extension, not any others.
    5768             :      */
    5769          32 :     for (i = 0; i < dobj->nDeps; i++)
    5770             :     {
    5771          32 :         extobj = findObjectByDumpId(dobj->dependencies[i]);
    5772          32 :         if (extobj && extobj->objType == DO_EXTENSION)
    5773          32 :             break;
    5774           0 :         extobj = NULL;
    5775             :     }
    5776          32 :     if (extobj == NULL)
    5777           0 :         pg_fatal("could not find parent extension for %s %s",
    5778             :                  objtype, objname);
    5779             : 
    5780          32 :     appendPQExpBufferStr(upgrade_buffer,
    5781             :                          "\n-- For binary upgrade, handle extension membership the hard way\n");
    5782          32 :     appendPQExpBuffer(upgrade_buffer, "ALTER EXTENSION %s ADD %s ",
    5783          32 :                       fmtId(extobj->name),
    5784             :                       objtype);
    5785          32 :     if (objnamespace && *objnamespace)
    5786          26 :         appendPQExpBuffer(upgrade_buffer, "%s.", fmtId(objnamespace));
    5787          32 :     appendPQExpBuffer(upgrade_buffer, "%s;\n", objname);
    5788             : }
    5789             : 
    5790             : /*
    5791             :  * getNamespaces:
    5792             :  *    get information about all namespaces in the system catalogs
    5793             :  */
    5794             : void
    5795         470 : getNamespaces(Archive *fout)
    5796             : {
    5797             :     PGresult   *res;
    5798             :     int         ntups;
    5799             :     int         i;
    5800             :     PQExpBuffer query;
    5801             :     NamespaceInfo *nsinfo;
    5802             :     int         i_tableoid;
    5803             :     int         i_oid;
    5804             :     int         i_nspname;
    5805             :     int         i_nspowner;
    5806             :     int         i_nspacl;
    5807             :     int         i_acldefault;
    5808             : 
    5809         470 :     query = createPQExpBuffer();
    5810             : 
    5811             :     /*
    5812             :      * we fetch all namespaces including system ones, so that every object we
    5813             :      * read in can be linked to a containing namespace.
    5814             :      */
    5815         470 :     appendPQExpBufferStr(query, "SELECT n.tableoid, n.oid, n.nspname, "
    5816             :                          "n.nspowner, "
    5817             :                          "n.nspacl, "
    5818             :                          "acldefault('n', n.nspowner) AS acldefault "
    5819             :                          "FROM pg_namespace n");
    5820             : 
    5821         470 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    5822             : 
    5823         470 :     ntups = PQntuples(res);
    5824             : 
    5825         470 :     nsinfo = (NamespaceInfo *) pg_malloc(ntups * sizeof(NamespaceInfo));
    5826             : 
    5827         470 :     i_tableoid = PQfnumber(res, "tableoid");
    5828         470 :     i_oid = PQfnumber(res, "oid");
    5829         470 :     i_nspname = PQfnumber(res, "nspname");
    5830         470 :     i_nspowner = PQfnumber(res, "nspowner");
    5831         470 :     i_nspacl = PQfnumber(res, "nspacl");
    5832         470 :     i_acldefault = PQfnumber(res, "acldefault");
    5833             : 
    5834        4258 :     for (i = 0; i < ntups; i++)
    5835             :     {
    5836             :         const char *nspowner;
    5837             : 
    5838        3788 :         nsinfo[i].dobj.objType = DO_NAMESPACE;
    5839        3788 :         nsinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    5840        3788 :         nsinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    5841        3788 :         AssignDumpId(&nsinfo[i].dobj);
    5842        3788 :         nsinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_nspname));
    5843        3788 :         nsinfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_nspacl));
    5844        3788 :         nsinfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    5845        3788 :         nsinfo[i].dacl.privtype = 0;
    5846        3788 :         nsinfo[i].dacl.initprivs = NULL;
    5847        3788 :         nspowner = PQgetvalue(res, i, i_nspowner);
    5848        3788 :         nsinfo[i].nspowner = atooid(nspowner);
    5849        3788 :         nsinfo[i].rolname = getRoleName(nspowner);
    5850             : 
    5851             :         /* Decide whether to dump this namespace */
    5852        3788 :         selectDumpableNamespace(&nsinfo[i], fout);
    5853             : 
    5854             :         /* Mark whether namespace has an ACL */
    5855        3788 :         if (!PQgetisnull(res, i, i_nspacl))
    5856        1572 :             nsinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
    5857             : 
    5858             :         /*
    5859             :          * We ignore any pg_init_privs.initprivs entry for the public schema
    5860             :          * and assume a predetermined default, for several reasons.  First,
    5861             :          * dropping and recreating the schema removes its pg_init_privs entry,
    5862             :          * but an empty destination database starts with this ACL nonetheless.
    5863             :          * Second, we support dump/reload of public schema ownership changes.
    5864             :          * ALTER SCHEMA OWNER filters nspacl through aclnewowner(), but
    5865             :          * initprivs continues to reflect the initial owner.  Hence,
    5866             :          * synthesize the value that nspacl will have after the restore's
    5867             :          * ALTER SCHEMA OWNER.  Third, this makes the destination database
    5868             :          * match the source's ACL, even if the latter was an initdb-default
    5869             :          * ACL, which changed in v15.  An upgrade pulls in changes to most
    5870             :          * system object ACLs that the DBA had not customized.  We've made the
    5871             :          * public schema depart from that, because changing its ACL so easily
    5872             :          * breaks applications.
    5873             :          */
    5874        3788 :         if (strcmp(nsinfo[i].dobj.name, "public") == 0)
    5875             :         {
    5876         462 :             PQExpBuffer aclarray = createPQExpBuffer();
    5877         462 :             PQExpBuffer aclitem = createPQExpBuffer();
    5878             : 
    5879             :             /* Standard ACL as of v15 is {owner=UC/owner,=U/owner} */
    5880         462 :             appendPQExpBufferChar(aclarray, '{');
    5881         462 :             quoteAclUserName(aclitem, nsinfo[i].rolname);
    5882         462 :             appendPQExpBufferStr(aclitem, "=UC/");
    5883         462 :             quoteAclUserName(aclitem, nsinfo[i].rolname);
    5884         462 :             appendPGArray(aclarray, aclitem->data);
    5885         462 :             resetPQExpBuffer(aclitem);
    5886         462 :             appendPQExpBufferStr(aclitem, "=U/");
    5887         462 :             quoteAclUserName(aclitem, nsinfo[i].rolname);
    5888         462 :             appendPGArray(aclarray, aclitem->data);
    5889         462 :             appendPQExpBufferChar(aclarray, '}');
    5890             : 
    5891         462 :             nsinfo[i].dacl.privtype = 'i';
    5892         462 :             nsinfo[i].dacl.initprivs = pstrdup(aclarray->data);
    5893         462 :             nsinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
    5894             : 
    5895         462 :             destroyPQExpBuffer(aclarray);
    5896         462 :             destroyPQExpBuffer(aclitem);
    5897             :         }
    5898             :     }
    5899             : 
    5900         470 :     PQclear(res);
    5901         470 :     destroyPQExpBuffer(query);
    5902         470 : }
    5903             : 
    5904             : /*
    5905             :  * findNamespace:
    5906             :  *      given a namespace OID, look up the info read by getNamespaces
    5907             :  */
    5908             : static NamespaceInfo *
    5909     1462916 : findNamespace(Oid nsoid)
    5910             : {
    5911             :     NamespaceInfo *nsinfo;
    5912             : 
    5913     1462916 :     nsinfo = findNamespaceByOid(nsoid);
    5914     1462916 :     if (nsinfo == NULL)
    5915           0 :         pg_fatal("schema with OID %u does not exist", nsoid);
    5916     1462916 :     return nsinfo;
    5917             : }
    5918             : 
    5919             : /*
    5920             :  * getExtensions:
    5921             :  *    read all extensions in the system catalogs and return them in the
    5922             :  * ExtensionInfo* structure
    5923             :  *
    5924             :  *  numExtensions is set to the number of extensions read in
    5925             :  */
    5926             : ExtensionInfo *
    5927         470 : getExtensions(Archive *fout, int *numExtensions)
    5928             : {
    5929         470 :     DumpOptions *dopt = fout->dopt;
    5930             :     PGresult   *res;
    5931             :     int         ntups;
    5932             :     int         i;
    5933             :     PQExpBuffer query;
    5934         470 :     ExtensionInfo *extinfo = NULL;
    5935             :     int         i_tableoid;
    5936             :     int         i_oid;
    5937             :     int         i_extname;
    5938             :     int         i_nspname;
    5939             :     int         i_extrelocatable;
    5940             :     int         i_extversion;
    5941             :     int         i_extconfig;
    5942             :     int         i_extcondition;
    5943             : 
    5944         470 :     query = createPQExpBuffer();
    5945             : 
    5946         470 :     appendPQExpBufferStr(query, "SELECT x.tableoid, x.oid, "
    5947             :                          "x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
    5948             :                          "FROM pg_extension x "
    5949             :                          "JOIN pg_namespace n ON n.oid = x.extnamespace");
    5950             : 
    5951         470 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    5952             : 
    5953         470 :     ntups = PQntuples(res);
    5954         470 :     if (ntups == 0)
    5955           0 :         goto cleanup;
    5956             : 
    5957         470 :     extinfo = (ExtensionInfo *) pg_malloc(ntups * sizeof(ExtensionInfo));
    5958             : 
    5959         470 :     i_tableoid = PQfnumber(res, "tableoid");
    5960         470 :     i_oid = PQfnumber(res, "oid");
    5961         470 :     i_extname = PQfnumber(res, "extname");
    5962         470 :     i_nspname = PQfnumber(res, "nspname");
    5963         470 :     i_extrelocatable = PQfnumber(res, "extrelocatable");
    5964         470 :     i_extversion = PQfnumber(res, "extversion");
    5965         470 :     i_extconfig = PQfnumber(res, "extconfig");
    5966         470 :     i_extcondition = PQfnumber(res, "extcondition");
    5967             : 
    5968         990 :     for (i = 0; i < ntups; i++)
    5969             :     {
    5970         520 :         extinfo[i].dobj.objType = DO_EXTENSION;
    5971         520 :         extinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    5972         520 :         extinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    5973         520 :         AssignDumpId(&extinfo[i].dobj);
    5974         520 :         extinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_extname));
    5975         520 :         extinfo[i].namespace = pg_strdup(PQgetvalue(res, i, i_nspname));
    5976         520 :         extinfo[i].relocatable = *(PQgetvalue(res, i, i_extrelocatable)) == 't';
    5977         520 :         extinfo[i].extversion = pg_strdup(PQgetvalue(res, i, i_extversion));
    5978         520 :         extinfo[i].extconfig = pg_strdup(PQgetvalue(res, i, i_extconfig));
    5979         520 :         extinfo[i].extcondition = pg_strdup(PQgetvalue(res, i, i_extcondition));
    5980             : 
    5981             :         /* Decide whether we want to dump it */
    5982         520 :         selectDumpableExtension(&(extinfo[i]), dopt);
    5983             :     }
    5984             : 
    5985         470 : cleanup:
    5986         470 :     PQclear(res);
    5987         470 :     destroyPQExpBuffer(query);
    5988             : 
    5989         470 :     *numExtensions = ntups;
    5990             : 
    5991         470 :     return extinfo;
    5992             : }
    5993             : 
    5994             : /*
    5995             :  * getTypes:
    5996             :  *    get information about all types in the system catalogs
    5997             :  *
    5998             :  * NB: this must run after getFuncs() because we assume we can do
    5999             :  * findFuncByOid().
    6000             :  */
    6001             : void
    6002         468 : getTypes(Archive *fout)
    6003             : {
    6004             :     PGresult   *res;
    6005             :     int         ntups;
    6006             :     int         i;
    6007         468 :     PQExpBuffer query = createPQExpBuffer();
    6008             :     TypeInfo   *tyinfo;
    6009             :     ShellTypeInfo *stinfo;
    6010             :     int         i_tableoid;
    6011             :     int         i_oid;
    6012             :     int         i_typname;
    6013             :     int         i_typnamespace;
    6014             :     int         i_typacl;
    6015             :     int         i_acldefault;
    6016             :     int         i_typowner;
    6017             :     int         i_typelem;
    6018             :     int         i_typrelid;
    6019             :     int         i_typrelkind;
    6020             :     int         i_typtype;
    6021             :     int         i_typisdefined;
    6022             :     int         i_isarray;
    6023             :     int         i_typarray;
    6024             : 
    6025             :     /*
    6026             :      * we include even the built-in types because those may be used as array
    6027             :      * elements by user-defined types
    6028             :      *
    6029             :      * we filter out the built-in types when we dump out the types
    6030             :      *
    6031             :      * same approach for undefined (shell) types and array types
    6032             :      *
    6033             :      * Note: as of 8.3 we can reliably detect whether a type is an
    6034             :      * auto-generated array type by checking the element type's typarray.
    6035             :      * (Before that the test is capable of generating false positives.) We
    6036             :      * still check for name beginning with '_', though, so as to avoid the
    6037             :      * cost of the subselect probe for all standard types.  This would have to
    6038             :      * be revisited if the backend ever allows renaming of array types.
    6039             :      */
    6040         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, typname, "
    6041             :                          "typnamespace, typacl, "
    6042             :                          "acldefault('T', typowner) AS acldefault, "
    6043             :                          "typowner, "
    6044             :                          "typelem, typrelid, typarray, "
    6045             :                          "CASE WHEN typrelid = 0 THEN ' '::\"char\" "
    6046             :                          "ELSE (SELECT relkind FROM pg_class WHERE oid = typrelid) END AS typrelkind, "
    6047             :                          "typtype, typisdefined, "
    6048             :                          "typname[0] = '_' AND typelem != 0 AND "
    6049             :                          "(SELECT typarray FROM pg_type te WHERE oid = pg_type.typelem) = oid AS isarray "
    6050             :                          "FROM pg_type");
    6051             : 
    6052         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6053             : 
    6054         468 :     ntups = PQntuples(res);
    6055             : 
    6056         468 :     tyinfo = (TypeInfo *) pg_malloc(ntups * sizeof(TypeInfo));
    6057             : 
    6058         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6059         468 :     i_oid = PQfnumber(res, "oid");
    6060         468 :     i_typname = PQfnumber(res, "typname");
    6061         468 :     i_typnamespace = PQfnumber(res, "typnamespace");
    6062         468 :     i_typacl = PQfnumber(res, "typacl");
    6063         468 :     i_acldefault = PQfnumber(res, "acldefault");
    6064         468 :     i_typowner = PQfnumber(res, "typowner");
    6065         468 :     i_typelem = PQfnumber(res, "typelem");
    6066         468 :     i_typrelid = PQfnumber(res, "typrelid");
    6067         468 :     i_typrelkind = PQfnumber(res, "typrelkind");
    6068         468 :     i_typtype = PQfnumber(res, "typtype");
    6069         468 :     i_typisdefined = PQfnumber(res, "typisdefined");
    6070         468 :     i_isarray = PQfnumber(res, "isarray");
    6071         468 :     i_typarray = PQfnumber(res, "typarray");
    6072             : 
    6073      337146 :     for (i = 0; i < ntups; i++)
    6074             :     {
    6075      336678 :         tyinfo[i].dobj.objType = DO_TYPE;
    6076      336678 :         tyinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6077      336678 :         tyinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6078      336678 :         AssignDumpId(&tyinfo[i].dobj);
    6079      336678 :         tyinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_typname));
    6080      673356 :         tyinfo[i].dobj.namespace =
    6081      336678 :             findNamespace(atooid(PQgetvalue(res, i, i_typnamespace)));
    6082      336678 :         tyinfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_typacl));
    6083      336678 :         tyinfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    6084      336678 :         tyinfo[i].dacl.privtype = 0;
    6085      336678 :         tyinfo[i].dacl.initprivs = NULL;
    6086      336678 :         tyinfo[i].ftypname = NULL;  /* may get filled later */
    6087      336678 :         tyinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_typowner));
    6088      336678 :         tyinfo[i].typelem = atooid(PQgetvalue(res, i, i_typelem));
    6089      336678 :         tyinfo[i].typrelid = atooid(PQgetvalue(res, i, i_typrelid));
    6090      336678 :         tyinfo[i].typrelkind = *PQgetvalue(res, i, i_typrelkind);
    6091      336678 :         tyinfo[i].typtype = *PQgetvalue(res, i, i_typtype);
    6092      336678 :         tyinfo[i].shellType = NULL;
    6093             : 
    6094      336678 :         if (strcmp(PQgetvalue(res, i, i_typisdefined), "t") == 0)
    6095      336560 :             tyinfo[i].isDefined = true;
    6096             :         else
    6097         118 :             tyinfo[i].isDefined = false;
    6098             : 
    6099      336678 :         if (strcmp(PQgetvalue(res, i, i_isarray), "t") == 0)
    6100      161494 :             tyinfo[i].isArray = true;
    6101             :         else
    6102      175184 :             tyinfo[i].isArray = false;
    6103             : 
    6104      336678 :         tyinfo[i].typarray = atooid(PQgetvalue(res, i, i_typarray));
    6105             : 
    6106      336678 :         if (tyinfo[i].typtype == TYPTYPE_MULTIRANGE)
    6107        3124 :             tyinfo[i].isMultirange = true;
    6108             :         else
    6109      333554 :             tyinfo[i].isMultirange = false;
    6110             : 
    6111             :         /* Decide whether we want to dump it */
    6112      336678 :         selectDumpableType(&tyinfo[i], fout);
    6113             : 
    6114             :         /* Mark whether type has an ACL */
    6115      336678 :         if (!PQgetisnull(res, i, i_typacl))
    6116         442 :             tyinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
    6117             : 
    6118             :         /*
    6119             :          * If it's a domain, fetch info about its constraints, if any
    6120             :          */
    6121      336678 :         tyinfo[i].nDomChecks = 0;
    6122      336678 :         tyinfo[i].domChecks = NULL;
    6123      336678 :         if ((tyinfo[i].dobj.dump & DUMP_COMPONENT_DEFINITION) &&
    6124       39900 :             tyinfo[i].typtype == TYPTYPE_DOMAIN)
    6125         452 :             getDomainConstraints(fout, &(tyinfo[i]));
    6126             : 
    6127             :         /*
    6128             :          * If it's a base type, make a DumpableObject representing a shell
    6129             :          * definition of the type.  We will need to dump that ahead of the I/O
    6130             :          * functions for the type.  Similarly, range types need a shell
    6131             :          * definition in case they have a canonicalize function.
    6132             :          *
    6133             :          * Note: the shell type doesn't have a catId.  You might think it
    6134             :          * should copy the base type's catId, but then it might capture the
    6135             :          * pg_depend entries for the type, which we don't want.
    6136             :          */
    6137      336678 :         if ((tyinfo[i].dobj.dump & DUMP_COMPONENT_DEFINITION) &&
    6138       39900 :             (tyinfo[i].typtype == TYPTYPE_BASE ||
    6139       19486 :              tyinfo[i].typtype == TYPTYPE_RANGE))
    6140             :         {
    6141       20714 :             stinfo = (ShellTypeInfo *) pg_malloc(sizeof(ShellTypeInfo));
    6142       20714 :             stinfo->dobj.objType = DO_SHELL_TYPE;
    6143       20714 :             stinfo->dobj.catId = nilCatalogId;
    6144       20714 :             AssignDumpId(&stinfo->dobj);
    6145       20714 :             stinfo->dobj.name = pg_strdup(tyinfo[i].dobj.name);
    6146       20714 :             stinfo->dobj.namespace = tyinfo[i].dobj.namespace;
    6147       20714 :             stinfo->baseType = &(tyinfo[i]);
    6148       20714 :             tyinfo[i].shellType = stinfo;
    6149             : 
    6150             :             /*
    6151             :              * Initially mark the shell type as not to be dumped.  We'll only
    6152             :              * dump it if the I/O or canonicalize functions need to be dumped;
    6153             :              * this is taken care of while sorting dependencies.
    6154             :              */
    6155       20714 :             stinfo->dobj.dump = DUMP_COMPONENT_NONE;
    6156             :         }
    6157             :     }
    6158             : 
    6159         468 :     PQclear(res);
    6160             : 
    6161         468 :     destroyPQExpBuffer(query);
    6162         468 : }
    6163             : 
    6164             : /*
    6165             :  * getOperators:
    6166             :  *    get information about all operators in the system catalogs
    6167             :  */
    6168             : void
    6169         468 : getOperators(Archive *fout)
    6170             : {
    6171             :     PGresult   *res;
    6172             :     int         ntups;
    6173             :     int         i;
    6174         468 :     PQExpBuffer query = createPQExpBuffer();
    6175             :     OprInfo    *oprinfo;
    6176             :     int         i_tableoid;
    6177             :     int         i_oid;
    6178             :     int         i_oprname;
    6179             :     int         i_oprnamespace;
    6180             :     int         i_oprowner;
    6181             :     int         i_oprkind;
    6182             :     int         i_oprcode;
    6183             : 
    6184             :     /*
    6185             :      * find all operators, including builtin operators; we filter out
    6186             :      * system-defined operators at dump-out time.
    6187             :      */
    6188             : 
    6189         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, oprname, "
    6190             :                          "oprnamespace, "
    6191             :                          "oprowner, "
    6192             :                          "oprkind, "
    6193             :                          "oprcode::oid AS oprcode "
    6194             :                          "FROM pg_operator");
    6195             : 
    6196         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6197             : 
    6198         468 :     ntups = PQntuples(res);
    6199             : 
    6200         468 :     oprinfo = (OprInfo *) pg_malloc(ntups * sizeof(OprInfo));
    6201             : 
    6202         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6203         468 :     i_oid = PQfnumber(res, "oid");
    6204         468 :     i_oprname = PQfnumber(res, "oprname");
    6205         468 :     i_oprnamespace = PQfnumber(res, "oprnamespace");
    6206         468 :     i_oprowner = PQfnumber(res, "oprowner");
    6207         468 :     i_oprkind = PQfnumber(res, "oprkind");
    6208         468 :     i_oprcode = PQfnumber(res, "oprcode");
    6209             : 
    6210      374774 :     for (i = 0; i < ntups; i++)
    6211             :     {
    6212      374306 :         oprinfo[i].dobj.objType = DO_OPERATOR;
    6213      374306 :         oprinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6214      374306 :         oprinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6215      374306 :         AssignDumpId(&oprinfo[i].dobj);
    6216      374306 :         oprinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_oprname));
    6217      748612 :         oprinfo[i].dobj.namespace =
    6218      374306 :             findNamespace(atooid(PQgetvalue(res, i, i_oprnamespace)));
    6219      374306 :         oprinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_oprowner));
    6220      374306 :         oprinfo[i].oprkind = (PQgetvalue(res, i, i_oprkind))[0];
    6221      374306 :         oprinfo[i].oprcode = atooid(PQgetvalue(res, i, i_oprcode));
    6222             : 
    6223             :         /* Decide whether we want to dump it */
    6224      374306 :         selectDumpableObject(&(oprinfo[i].dobj), fout);
    6225             :     }
    6226             : 
    6227         468 :     PQclear(res);
    6228             : 
    6229         468 :     destroyPQExpBuffer(query);
    6230         468 : }
    6231             : 
    6232             : /*
    6233             :  * getCollations:
    6234             :  *    get information about all collations in the system catalogs
    6235             :  */
    6236             : void
    6237         468 : getCollations(Archive *fout)
    6238             : {
    6239             :     PGresult   *res;
    6240             :     int         ntups;
    6241             :     int         i;
    6242             :     PQExpBuffer query;
    6243             :     CollInfo   *collinfo;
    6244             :     int         i_tableoid;
    6245             :     int         i_oid;
    6246             :     int         i_collname;
    6247             :     int         i_collnamespace;
    6248             :     int         i_collowner;
    6249             : 
    6250         468 :     query = createPQExpBuffer();
    6251             : 
    6252             :     /*
    6253             :      * find all collations, including builtin collations; we filter out
    6254             :      * system-defined collations at dump-out time.
    6255             :      */
    6256             : 
    6257         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, collname, "
    6258             :                          "collnamespace, "
    6259             :                          "collowner "
    6260             :                          "FROM pg_collation");
    6261             : 
    6262         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6263             : 
    6264         468 :     ntups = PQntuples(res);
    6265             : 
    6266         468 :     collinfo = (CollInfo *) pg_malloc(ntups * sizeof(CollInfo));
    6267             : 
    6268         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6269         468 :     i_oid = PQfnumber(res, "oid");
    6270         468 :     i_collname = PQfnumber(res, "collname");
    6271         468 :     i_collnamespace = PQfnumber(res, "collnamespace");
    6272         468 :     i_collowner = PQfnumber(res, "collowner");
    6273             : 
    6274      371848 :     for (i = 0; i < ntups; i++)
    6275             :     {
    6276      371380 :         collinfo[i].dobj.objType = DO_COLLATION;
    6277      371380 :         collinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6278      371380 :         collinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6279      371380 :         AssignDumpId(&collinfo[i].dobj);
    6280      371380 :         collinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_collname));
    6281      742760 :         collinfo[i].dobj.namespace =
    6282      371380 :             findNamespace(atooid(PQgetvalue(res, i, i_collnamespace)));
    6283      371380 :         collinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_collowner));
    6284             : 
    6285             :         /* Decide whether we want to dump it */
    6286      371380 :         selectDumpableObject(&(collinfo[i].dobj), fout);
    6287             :     }
    6288             : 
    6289         468 :     PQclear(res);
    6290             : 
    6291         468 :     destroyPQExpBuffer(query);
    6292         468 : }
    6293             : 
    6294             : /*
    6295             :  * getConversions:
    6296             :  *    get information about all conversions in the system catalogs
    6297             :  */
    6298             : void
    6299         468 : getConversions(Archive *fout)
    6300             : {
    6301             :     PGresult   *res;
    6302             :     int         ntups;
    6303             :     int         i;
    6304             :     PQExpBuffer query;
    6305             :     ConvInfo   *convinfo;
    6306             :     int         i_tableoid;
    6307             :     int         i_oid;
    6308             :     int         i_conname;
    6309             :     int         i_connamespace;
    6310             :     int         i_conowner;
    6311             : 
    6312         468 :     query = createPQExpBuffer();
    6313             : 
    6314             :     /*
    6315             :      * find all conversions, including builtin conversions; we filter out
    6316             :      * system-defined conversions at dump-out time.
    6317             :      */
    6318             : 
    6319         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, conname, "
    6320             :                          "connamespace, "
    6321             :                          "conowner "
    6322             :                          "FROM pg_conversion");
    6323             : 
    6324         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6325             : 
    6326         468 :     ntups = PQntuples(res);
    6327             : 
    6328         468 :     convinfo = (ConvInfo *) pg_malloc(ntups * sizeof(ConvInfo));
    6329             : 
    6330         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6331         468 :     i_oid = PQfnumber(res, "oid");
    6332         468 :     i_conname = PQfnumber(res, "conname");
    6333         468 :     i_connamespace = PQfnumber(res, "connamespace");
    6334         468 :     i_conowner = PQfnumber(res, "conowner");
    6335             : 
    6336       60470 :     for (i = 0; i < ntups; i++)
    6337             :     {
    6338       60002 :         convinfo[i].dobj.objType = DO_CONVERSION;
    6339       60002 :         convinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6340       60002 :         convinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6341       60002 :         AssignDumpId(&convinfo[i].dobj);
    6342       60002 :         convinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_conname));
    6343      120004 :         convinfo[i].dobj.namespace =
    6344       60002 :             findNamespace(atooid(PQgetvalue(res, i, i_connamespace)));
    6345       60002 :         convinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_conowner));
    6346             : 
    6347             :         /* Decide whether we want to dump it */
    6348       60002 :         selectDumpableObject(&(convinfo[i].dobj), fout);
    6349             :     }
    6350             : 
    6351         468 :     PQclear(res);
    6352             : 
    6353         468 :     destroyPQExpBuffer(query);
    6354         468 : }
    6355             : 
    6356             : /*
    6357             :  * getAccessMethods:
    6358             :  *    get information about all user-defined access methods
    6359             :  */
    6360             : void
    6361         468 : getAccessMethods(Archive *fout)
    6362             : {
    6363             :     PGresult   *res;
    6364             :     int         ntups;
    6365             :     int         i;
    6366             :     PQExpBuffer query;
    6367             :     AccessMethodInfo *aminfo;
    6368             :     int         i_tableoid;
    6369             :     int         i_oid;
    6370             :     int         i_amname;
    6371             :     int         i_amhandler;
    6372             :     int         i_amtype;
    6373             : 
    6374             :     /* Before 9.6, there are no user-defined access methods */
    6375         468 :     if (fout->remoteVersion < 90600)
    6376           0 :         return;
    6377             : 
    6378         468 :     query = createPQExpBuffer();
    6379             : 
    6380             :     /* Select all access methods from pg_am table */
    6381         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, amname, amtype, "
    6382             :                          "amhandler::pg_catalog.regproc AS amhandler "
    6383             :                          "FROM pg_am");
    6384             : 
    6385         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6386             : 
    6387         468 :     ntups = PQntuples(res);
    6388             : 
    6389         468 :     aminfo = (AccessMethodInfo *) pg_malloc(ntups * sizeof(AccessMethodInfo));
    6390             : 
    6391         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6392         468 :     i_oid = PQfnumber(res, "oid");
    6393         468 :     i_amname = PQfnumber(res, "amname");
    6394         468 :     i_amhandler = PQfnumber(res, "amhandler");
    6395         468 :     i_amtype = PQfnumber(res, "amtype");
    6396             : 
    6397        4010 :     for (i = 0; i < ntups; i++)
    6398             :     {
    6399        3542 :         aminfo[i].dobj.objType = DO_ACCESS_METHOD;
    6400        3542 :         aminfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6401        3542 :         aminfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6402        3542 :         AssignDumpId(&aminfo[i].dobj);
    6403        3542 :         aminfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_amname));
    6404        3542 :         aminfo[i].dobj.namespace = NULL;
    6405        3542 :         aminfo[i].amhandler = pg_strdup(PQgetvalue(res, i, i_amhandler));
    6406        3542 :         aminfo[i].amtype = *(PQgetvalue(res, i, i_amtype));
    6407             : 
    6408             :         /* Decide whether we want to dump it */
    6409        3542 :         selectDumpableAccessMethod(&(aminfo[i]), fout);
    6410             :     }
    6411             : 
    6412         468 :     PQclear(res);
    6413             : 
    6414         468 :     destroyPQExpBuffer(query);
    6415             : }
    6416             : 
    6417             : 
    6418             : /*
    6419             :  * getOpclasses:
    6420             :  *    get information about all opclasses in the system catalogs
    6421             :  */
    6422             : void
    6423         468 : getOpclasses(Archive *fout)
    6424             : {
    6425             :     PGresult   *res;
    6426             :     int         ntups;
    6427             :     int         i;
    6428         468 :     PQExpBuffer query = createPQExpBuffer();
    6429             :     OpclassInfo *opcinfo;
    6430             :     int         i_tableoid;
    6431             :     int         i_oid;
    6432             :     int         i_opcname;
    6433             :     int         i_opcnamespace;
    6434             :     int         i_opcowner;
    6435             : 
    6436             :     /*
    6437             :      * find all opclasses, including builtin opclasses; we filter out
    6438             :      * system-defined opclasses at dump-out time.
    6439             :      */
    6440             : 
    6441         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, opcname, "
    6442             :                          "opcnamespace, "
    6443             :                          "opcowner "
    6444             :                          "FROM pg_opclass");
    6445             : 
    6446         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6447             : 
    6448         468 :     ntups = PQntuples(res);
    6449             : 
    6450         468 :     opcinfo = (OpclassInfo *) pg_malloc(ntups * sizeof(OpclassInfo));
    6451             : 
    6452         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6453         468 :     i_oid = PQfnumber(res, "oid");
    6454         468 :     i_opcname = PQfnumber(res, "opcname");
    6455         468 :     i_opcnamespace = PQfnumber(res, "opcnamespace");
    6456         468 :     i_opcowner = PQfnumber(res, "opcowner");
    6457             : 
    6458       83658 :     for (i = 0; i < ntups; i++)
    6459             :     {
    6460       83190 :         opcinfo[i].dobj.objType = DO_OPCLASS;
    6461       83190 :         opcinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6462       83190 :         opcinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6463       83190 :         AssignDumpId(&opcinfo[i].dobj);
    6464       83190 :         opcinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_opcname));
    6465      166380 :         opcinfo[i].dobj.namespace =
    6466       83190 :             findNamespace(atooid(PQgetvalue(res, i, i_opcnamespace)));
    6467       83190 :         opcinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_opcowner));
    6468             : 
    6469             :         /* Decide whether we want to dump it */
    6470       83190 :         selectDumpableObject(&(opcinfo[i].dobj), fout);
    6471             :     }
    6472             : 
    6473         468 :     PQclear(res);
    6474             : 
    6475         468 :     destroyPQExpBuffer(query);
    6476         468 : }
    6477             : 
    6478             : /*
    6479             :  * getOpfamilies:
    6480             :  *    get information about all opfamilies in the system catalogs
    6481             :  */
    6482             : void
    6483         468 : getOpfamilies(Archive *fout)
    6484             : {
    6485             :     PGresult   *res;
    6486             :     int         ntups;
    6487             :     int         i;
    6488             :     PQExpBuffer query;
    6489             :     OpfamilyInfo *opfinfo;
    6490             :     int         i_tableoid;
    6491             :     int         i_oid;
    6492             :     int         i_opfname;
    6493             :     int         i_opfnamespace;
    6494             :     int         i_opfowner;
    6495             : 
    6496         468 :     query = createPQExpBuffer();
    6497             : 
    6498             :     /*
    6499             :      * find all opfamilies, including builtin opfamilies; we filter out
    6500             :      * system-defined opfamilies at dump-out time.
    6501             :      */
    6502             : 
    6503         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, opfname, "
    6504             :                          "opfnamespace, "
    6505             :                          "opfowner "
    6506             :                          "FROM pg_opfamily");
    6507             : 
    6508         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6509             : 
    6510         468 :     ntups = PQntuples(res);
    6511             : 
    6512         468 :     opfinfo = (OpfamilyInfo *) pg_malloc(ntups * sizeof(OpfamilyInfo));
    6513             : 
    6514         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6515         468 :     i_oid = PQfnumber(res, "oid");
    6516         468 :     i_opfname = PQfnumber(res, "opfname");
    6517         468 :     i_opfnamespace = PQfnumber(res, "opfnamespace");
    6518         468 :     i_opfowner = PQfnumber(res, "opfowner");
    6519             : 
    6520       69132 :     for (i = 0; i < ntups; i++)
    6521             :     {
    6522       68664 :         opfinfo[i].dobj.objType = DO_OPFAMILY;
    6523       68664 :         opfinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6524       68664 :         opfinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6525       68664 :         AssignDumpId(&opfinfo[i].dobj);
    6526       68664 :         opfinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_opfname));
    6527      137328 :         opfinfo[i].dobj.namespace =
    6528       68664 :             findNamespace(atooid(PQgetvalue(res, i, i_opfnamespace)));
    6529       68664 :         opfinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_opfowner));
    6530             : 
    6531             :         /* Decide whether we want to dump it */
    6532       68664 :         selectDumpableObject(&(opfinfo[i].dobj), fout);
    6533             :     }
    6534             : 
    6535         468 :     PQclear(res);
    6536             : 
    6537         468 :     destroyPQExpBuffer(query);
    6538         468 : }
    6539             : 
    6540             : /*
    6541             :  * getAggregates:
    6542             :  *    get information about all user-defined aggregates in the system catalogs
    6543             :  */
    6544             : void
    6545         468 : getAggregates(Archive *fout)
    6546             : {
    6547         468 :     DumpOptions *dopt = fout->dopt;
    6548             :     PGresult   *res;
    6549             :     int         ntups;
    6550             :     int         i;
    6551         468 :     PQExpBuffer query = createPQExpBuffer();
    6552             :     AggInfo    *agginfo;
    6553             :     int         i_tableoid;
    6554             :     int         i_oid;
    6555             :     int         i_aggname;
    6556             :     int         i_aggnamespace;
    6557             :     int         i_pronargs;
    6558             :     int         i_proargtypes;
    6559             :     int         i_proowner;
    6560             :     int         i_aggacl;
    6561             :     int         i_acldefault;
    6562             : 
    6563             :     /*
    6564             :      * Find all interesting aggregates.  See comment in getFuncs() for the
    6565             :      * rationale behind the filtering logic.
    6566             :      */
    6567         468 :     if (fout->remoteVersion >= 90600)
    6568             :     {
    6569             :         const char *agg_check;
    6570             : 
    6571         936 :         agg_check = (fout->remoteVersion >= 110000 ? "p.prokind = 'a'"
    6572         468 :                      : "p.proisagg");
    6573             : 
    6574         468 :         appendPQExpBuffer(query, "SELECT p.tableoid, p.oid, "
    6575             :                           "p.proname AS aggname, "
    6576             :                           "p.pronamespace AS aggnamespace, "
    6577             :                           "p.pronargs, p.proargtypes, "
    6578             :                           "p.proowner, "
    6579             :                           "p.proacl AS aggacl, "
    6580             :                           "acldefault('f', p.proowner) AS acldefault "
    6581             :                           "FROM pg_proc p "
    6582             :                           "LEFT JOIN pg_init_privs pip ON "
    6583             :                           "(p.oid = pip.objoid "
    6584             :                           "AND pip.classoid = 'pg_proc'::regclass "
    6585             :                           "AND pip.objsubid = 0) "
    6586             :                           "WHERE %s AND ("
    6587             :                           "p.pronamespace != "
    6588             :                           "(SELECT oid FROM pg_namespace "
    6589             :                           "WHERE nspname = 'pg_catalog') OR "
    6590             :                           "p.proacl IS DISTINCT FROM pip.initprivs",
    6591             :                           agg_check);
    6592         468 :         if (dopt->binary_upgrade)
    6593          62 :             appendPQExpBufferStr(query,
    6594             :                                  " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
    6595             :                                  "classid = 'pg_proc'::regclass AND "
    6596             :                                  "objid = p.oid AND "
    6597             :                                  "refclassid = 'pg_extension'::regclass AND "
    6598             :                                  "deptype = 'e')");
    6599         468 :         appendPQExpBufferChar(query, ')');
    6600             :     }
    6601             :     else
    6602             :     {
    6603           0 :         appendPQExpBufferStr(query, "SELECT tableoid, oid, proname AS aggname, "
    6604             :                              "pronamespace AS aggnamespace, "
    6605             :                              "pronargs, proargtypes, "
    6606             :                              "proowner, "
    6607             :                              "proacl AS aggacl, "
    6608             :                              "acldefault('f', proowner) AS acldefault "
    6609             :                              "FROM pg_proc p "
    6610             :                              "WHERE proisagg AND ("
    6611             :                              "pronamespace != "
    6612             :                              "(SELECT oid FROM pg_namespace "
    6613             :                              "WHERE nspname = 'pg_catalog')");
    6614           0 :         if (dopt->binary_upgrade)
    6615           0 :             appendPQExpBufferStr(query,
    6616             :                                  " OR EXISTS(SELECT 1 FROM pg_depend WHERE "
    6617             :                                  "classid = 'pg_proc'::regclass AND "
    6618             :                                  "objid = p.oid AND "
    6619             :                                  "refclassid = 'pg_extension'::regclass AND "
    6620             :                                  "deptype = 'e')");
    6621           0 :         appendPQExpBufferChar(query, ')');
    6622             :     }
    6623             : 
    6624         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6625             : 
    6626         468 :     ntups = PQntuples(res);
    6627             : 
    6628         468 :     agginfo = (AggInfo *) pg_malloc(ntups * sizeof(AggInfo));
    6629             : 
    6630         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6631         468 :     i_oid = PQfnumber(res, "oid");
    6632         468 :     i_aggname = PQfnumber(res, "aggname");
    6633         468 :     i_aggnamespace = PQfnumber(res, "aggnamespace");
    6634         468 :     i_pronargs = PQfnumber(res, "pronargs");
    6635         468 :     i_proargtypes = PQfnumber(res, "proargtypes");
    6636         468 :     i_proowner = PQfnumber(res, "proowner");
    6637         468 :     i_aggacl = PQfnumber(res, "aggacl");
    6638         468 :     i_acldefault = PQfnumber(res, "acldefault");
    6639             : 
    6640        1556 :     for (i = 0; i < ntups; i++)
    6641             :     {
    6642        1088 :         agginfo[i].aggfn.dobj.objType = DO_AGG;
    6643        1088 :         agginfo[i].aggfn.dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6644        1088 :         agginfo[i].aggfn.dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6645        1088 :         AssignDumpId(&agginfo[i].aggfn.dobj);
    6646        1088 :         agginfo[i].aggfn.dobj.name = pg_strdup(PQgetvalue(res, i, i_aggname));
    6647        2176 :         agginfo[i].aggfn.dobj.namespace =
    6648        1088 :             findNamespace(atooid(PQgetvalue(res, i, i_aggnamespace)));
    6649        1088 :         agginfo[i].aggfn.dacl.acl = pg_strdup(PQgetvalue(res, i, i_aggacl));
    6650        1088 :         agginfo[i].aggfn.dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    6651        1088 :         agginfo[i].aggfn.dacl.privtype = 0;
    6652        1088 :         agginfo[i].aggfn.dacl.initprivs = NULL;
    6653        1088 :         agginfo[i].aggfn.rolname = getRoleName(PQgetvalue(res, i, i_proowner));
    6654        1088 :         agginfo[i].aggfn.lang = InvalidOid; /* not currently interesting */
    6655        1088 :         agginfo[i].aggfn.prorettype = InvalidOid;   /* not saved */
    6656        1088 :         agginfo[i].aggfn.nargs = atoi(PQgetvalue(res, i, i_pronargs));
    6657        1088 :         if (agginfo[i].aggfn.nargs == 0)
    6658         160 :             agginfo[i].aggfn.argtypes = NULL;
    6659             :         else
    6660             :         {
    6661         928 :             agginfo[i].aggfn.argtypes = (Oid *) pg_malloc(agginfo[i].aggfn.nargs * sizeof(Oid));
    6662         928 :             parseOidArray(PQgetvalue(res, i, i_proargtypes),
    6663         928 :                           agginfo[i].aggfn.argtypes,
    6664         928 :                           agginfo[i].aggfn.nargs);
    6665             :         }
    6666        1088 :         agginfo[i].aggfn.postponed_def = false; /* might get set during sort */
    6667             : 
    6668             :         /* Decide whether we want to dump it */
    6669        1088 :         selectDumpableObject(&(agginfo[i].aggfn.dobj), fout);
    6670             : 
    6671             :         /* Mark whether aggregate has an ACL */
    6672        1088 :         if (!PQgetisnull(res, i, i_aggacl))
    6673          50 :             agginfo[i].aggfn.dobj.components |= DUMP_COMPONENT_ACL;
    6674             :     }
    6675             : 
    6676         468 :     PQclear(res);
    6677             : 
    6678         468 :     destroyPQExpBuffer(query);
    6679         468 : }
    6680             : 
    6681             : /*
    6682             :  * getFuncs:
    6683             :  *    get information about all user-defined functions in the system catalogs
    6684             :  */
    6685             : void
    6686         468 : getFuncs(Archive *fout)
    6687             : {
    6688         468 :     DumpOptions *dopt = fout->dopt;
    6689             :     PGresult   *res;
    6690             :     int         ntups;
    6691             :     int         i;
    6692         468 :     PQExpBuffer query = createPQExpBuffer();
    6693             :     FuncInfo   *finfo;
    6694             :     int         i_tableoid;
    6695             :     int         i_oid;
    6696             :     int         i_proname;
    6697             :     int         i_pronamespace;
    6698             :     int         i_proowner;
    6699             :     int         i_prolang;
    6700             :     int         i_pronargs;
    6701             :     int         i_proargtypes;
    6702             :     int         i_prorettype;
    6703             :     int         i_proacl;
    6704             :     int         i_acldefault;
    6705             : 
    6706             :     /*
    6707             :      * Find all interesting functions.  This is a bit complicated:
    6708             :      *
    6709             :      * 1. Always exclude aggregates; those are handled elsewhere.
    6710             :      *
    6711             :      * 2. Always exclude functions that are internally dependent on something
    6712             :      * else, since presumably those will be created as a result of creating
    6713             :      * the something else.  This currently acts only to suppress constructor
    6714             :      * functions for range types.  Note this is OK only because the
    6715             :      * constructors don't have any dependencies the range type doesn't have;
    6716             :      * otherwise we might not get creation ordering correct.
    6717             :      *
    6718             :      * 3. Otherwise, we normally exclude functions in pg_catalog.  However, if
    6719             :      * they're members of extensions and we are in binary-upgrade mode then
    6720             :      * include them, since we want to dump extension members individually in
    6721             :      * that mode.  Also, if they are used by casts or transforms then we need
    6722             :      * to gather the information about them, though they won't be dumped if
    6723             :      * they are built-in.  Also, in 9.6 and up, include functions in
    6724             :      * pg_catalog if they have an ACL different from what's shown in
    6725             :      * pg_init_privs (so we have to join to pg_init_privs; annoying).
    6726             :      */
    6727         468 :     if (fout->remoteVersion >= 90600)
    6728             :     {
    6729             :         const char *not_agg_check;
    6730             : 
    6731         936 :         not_agg_check = (fout->remoteVersion >= 110000 ? "p.prokind <> 'a'"
    6732         468 :                          : "NOT p.proisagg");
    6733             : 
    6734         468 :         appendPQExpBuffer(query,
    6735             :                           "SELECT p.tableoid, p.oid, p.proname, p.prolang, "
    6736             :                           "p.pronargs, p.proargtypes, p.prorettype, "
    6737             :                           "p.proacl, "
    6738             :                           "acldefault('f', p.proowner) AS acldefault, "
    6739             :                           "p.pronamespace, "
    6740             :                           "p.proowner "
    6741             :                           "FROM pg_proc p "
    6742             :                           "LEFT JOIN pg_init_privs pip ON "
    6743             :                           "(p.oid = pip.objoid "
    6744             :                           "AND pip.classoid = 'pg_proc'::regclass "
    6745             :                           "AND pip.objsubid = 0) "
    6746             :                           "WHERE %s"
    6747             :                           "\n  AND NOT EXISTS (SELECT 1 FROM pg_depend "
    6748             :                           "WHERE classid = 'pg_proc'::regclass AND "
    6749             :                           "objid = p.oid AND deptype = 'i')"
    6750             :                           "\n  AND ("
    6751             :                           "\n  pronamespace != "
    6752             :                           "(SELECT oid FROM pg_namespace "
    6753             :                           "WHERE nspname = 'pg_catalog')"
    6754             :                           "\n  OR EXISTS (SELECT 1 FROM pg_cast"
    6755             :                           "\n  WHERE pg_cast.oid > %u "
    6756             :                           "\n  AND p.oid = pg_cast.castfunc)"
    6757             :                           "\n  OR EXISTS (SELECT 1 FROM pg_transform"
    6758             :                           "\n  WHERE pg_transform.oid > %u AND "
    6759             :                           "\n  (p.oid = pg_transform.trffromsql"
    6760             :                           "\n  OR p.oid = pg_transform.trftosql))",
    6761             :                           not_agg_check,
    6762             :                           g_last_builtin_oid,
    6763             :                           g_last_builtin_oid);
    6764         468 :         if (dopt->binary_upgrade)
    6765          62 :             appendPQExpBufferStr(query,
    6766             :                                  "\n  OR EXISTS(SELECT 1 FROM pg_depend WHERE "
    6767             :                                  "classid = 'pg_proc'::regclass AND "
    6768             :                                  "objid = p.oid AND "
    6769             :                                  "refclassid = 'pg_extension'::regclass AND "
    6770             :                                  "deptype = 'e')");
    6771         468 :         appendPQExpBufferStr(query,
    6772             :                              "\n  OR p.proacl IS DISTINCT FROM pip.initprivs");
    6773         468 :         appendPQExpBufferChar(query, ')');
    6774             :     }
    6775             :     else
    6776             :     {
    6777           0 :         appendPQExpBuffer(query,
    6778             :                           "SELECT tableoid, oid, proname, prolang, "
    6779             :                           "pronargs, proargtypes, prorettype, proacl, "
    6780             :                           "acldefault('f', proowner) AS acldefault, "
    6781             :                           "pronamespace, "
    6782             :                           "proowner "
    6783             :                           "FROM pg_proc p "
    6784             :                           "WHERE NOT proisagg"
    6785             :                           "\n  AND NOT EXISTS (SELECT 1 FROM pg_depend "
    6786             :                           "WHERE classid = 'pg_proc'::regclass AND "
    6787             :                           "objid = p.oid AND deptype = 'i')"
    6788             :                           "\n  AND ("
    6789             :                           "\n  pronamespace != "
    6790             :                           "(SELECT oid FROM pg_namespace "
    6791             :                           "WHERE nspname = 'pg_catalog')"
    6792             :                           "\n  OR EXISTS (SELECT 1 FROM pg_cast"
    6793             :                           "\n  WHERE pg_cast.oid > '%u'::oid"
    6794             :                           "\n  AND p.oid = pg_cast.castfunc)",
    6795             :                           g_last_builtin_oid);
    6796             : 
    6797           0 :         if (fout->remoteVersion >= 90500)
    6798           0 :             appendPQExpBuffer(query,
    6799             :                               "\n  OR EXISTS (SELECT 1 FROM pg_transform"
    6800             :                               "\n  WHERE pg_transform.oid > '%u'::oid"
    6801             :                               "\n  AND (p.oid = pg_transform.trffromsql"
    6802             :                               "\n  OR p.oid = pg_transform.trftosql))",
    6803             :                               g_last_builtin_oid);
    6804             : 
    6805           0 :         if (dopt->binary_upgrade)
    6806           0 :             appendPQExpBufferStr(query,
    6807             :                                  "\n  OR EXISTS(SELECT 1 FROM pg_depend WHERE "
    6808             :                                  "classid = 'pg_proc'::regclass AND "
    6809             :                                  "objid = p.oid AND "
    6810             :                                  "refclassid = 'pg_extension'::regclass AND "
    6811             :                                  "deptype = 'e')");
    6812           0 :         appendPQExpBufferChar(query, ')');
    6813             :     }
    6814             : 
    6815         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    6816             : 
    6817         468 :     ntups = PQntuples(res);
    6818             : 
    6819         468 :     finfo = (FuncInfo *) pg_malloc0(ntups * sizeof(FuncInfo));
    6820             : 
    6821         468 :     i_tableoid = PQfnumber(res, "tableoid");
    6822         468 :     i_oid = PQfnumber(res, "oid");
    6823         468 :     i_proname = PQfnumber(res, "proname");
    6824         468 :     i_pronamespace = PQfnumber(res, "pronamespace");
    6825         468 :     i_proowner = PQfnumber(res, "proowner");
    6826         468 :     i_prolang = PQfnumber(res, "prolang");
    6827         468 :     i_pronargs = PQfnumber(res, "pronargs");
    6828         468 :     i_proargtypes = PQfnumber(res, "proargtypes");
    6829         468 :     i_prorettype = PQfnumber(res, "prorettype");
    6830         468 :     i_proacl = PQfnumber(res, "proacl");
    6831         468 :     i_acldefault = PQfnumber(res, "acldefault");
    6832             : 
    6833       12766 :     for (i = 0; i < ntups; i++)
    6834             :     {
    6835       12298 :         finfo[i].dobj.objType = DO_FUNC;
    6836       12298 :         finfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    6837       12298 :         finfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    6838       12298 :         AssignDumpId(&finfo[i].dobj);
    6839       12298 :         finfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_proname));
    6840       24596 :         finfo[i].dobj.namespace =
    6841       12298 :             findNamespace(atooid(PQgetvalue(res, i, i_pronamespace)));
    6842       12298 :         finfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_proacl));
    6843       12298 :         finfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    6844       12298 :         finfo[i].dacl.privtype = 0;
    6845       12298 :         finfo[i].dacl.initprivs = NULL;
    6846       12298 :         finfo[i].rolname = getRoleName(PQgetvalue(res, i, i_proowner));
    6847       12298 :         finfo[i].lang = atooid(PQgetvalue(res, i, i_prolang));
    6848       12298 :         finfo[i].prorettype = atooid(PQgetvalue(res, i, i_prorettype));
    6849       12298 :         finfo[i].nargs = atoi(PQgetvalue(res, i, i_pronargs));
    6850       12298 :         if (finfo[i].nargs == 0)
    6851        2768 :             finfo[i].argtypes = NULL;
    6852             :         else
    6853             :         {
    6854        9530 :             finfo[i].argtypes = (Oid *) pg_malloc(finfo[i].nargs * sizeof(Oid));
    6855        9530 :             parseOidArray(PQgetvalue(res, i, i_proargtypes),
    6856        9530 :                           finfo[i].argtypes, finfo[i].nargs);
    6857             :         }
    6858       12298 :         finfo[i].postponed_def = false; /* might get set during sort */
    6859             : 
    6860             :         /* Decide whether we want to dump it */
    6861       12298 :         selectDumpableObject(&(finfo[i].dobj), fout);
    6862             : 
    6863             :         /* Mark whether function has an ACL */
    6864       12298 :         if (!PQgetisnull(res, i, i_proacl))
    6865         310 :             finfo[i].dobj.components |= DUMP_COMPONENT_ACL;
    6866             :     }
    6867             : 
    6868         468 :     PQclear(res);
    6869             : 
    6870         468 :     destroyPQExpBuffer(query);
    6871         468 : }
    6872             : 
    6873             : /*
    6874             :  * getRelationStatistics
    6875             :  *    register the statistics object as a dependent of the relation.
    6876             :  *
    6877             :  * reltuples is passed as a string to avoid complexities in converting from/to
    6878             :  * floating point.
    6879             :  */
    6880             : static RelStatsInfo *
    6881       25878 : getRelationStatistics(Archive *fout, DumpableObject *rel, int32 relpages,
    6882             :                       char *reltuples, int32 relallvisible,
    6883             :                       int32 relallfrozen, char relkind,
    6884             :                       char **indAttNames, int nindAttNames)
    6885             : {
    6886       25878 :     if (!fout->dopt->dumpStatistics)
    6887        5142 :         return NULL;
    6888             : 
    6889       20736 :     if ((relkind == RELKIND_RELATION) ||
    6890        8624 :         (relkind == RELKIND_PARTITIONED_TABLE) ||
    6891        4192 :         (relkind == RELKIND_INDEX) ||
    6892        2984 :         (relkind == RELKIND_PARTITIONED_INDEX) ||
    6893             :         (relkind == RELKIND_MATVIEW))
    6894             :     {
    6895       18608 :         RelStatsInfo *info = pg_malloc0(sizeof(RelStatsInfo));
    6896       18608 :         DumpableObject *dobj = &info->dobj;
    6897             : 
    6898       18608 :         dobj->objType = DO_REL_STATS;
    6899       18608 :         dobj->catId.tableoid = 0;
    6900       18608 :         dobj->catId.oid = 0;
    6901       18608 :         AssignDumpId(dobj);
    6902       18608 :         dobj->dependencies = (DumpId *) pg_malloc(sizeof(DumpId));
    6903       18608 :         dobj->dependencies[0] = rel->dumpId;
    6904       18608 :         dobj->nDeps = 1;
    6905       18608 :         dobj->allocDeps = 1;
    6906       18608 :         dobj->components |= DUMP_COMPONENT_STATISTICS;
    6907       18608 :         dobj->name = pg_strdup(rel->name);
    6908       18608 :         dobj->namespace = rel->namespace;
    6909       18608 :         info->relpages = relpages;
    6910       18608 :         info->reltuples = pstrdup(reltuples);
    6911       18608 :         info->relallvisible = relallvisible;
    6912       18608 :         info->relallfrozen = relallfrozen;
    6913       18608 :         info->relkind = relkind;
    6914       18608 :         info->indAttNames = indAttNames;
    6915       18608 :         info->nindAttNames = nindAttNames;
    6916             : 
    6917             :         /*
    6918             :          * Ordinarily, stats go in SECTION_DATA for tables and
    6919             :          * SECTION_POST_DATA for indexes.
    6920             :          *
    6921             :          * However, the section may be updated later for materialized view
    6922             :          * stats. REFRESH MATERIALIZED VIEW replaces the storage and resets
    6923             :          * the stats, so the stats must be restored after the data. Also, the
    6924             :          * materialized view definition may be postponed to SECTION_POST_DATA
    6925             :          * (see repairMatViewBoundaryMultiLoop()).
    6926             :          */
    6927       18608 :         switch (info->relkind)
    6928             :         {
    6929       12968 :             case RELKIND_RELATION:
    6930             :             case RELKIND_PARTITIONED_TABLE:
    6931             :             case RELKIND_MATVIEW:
    6932       12968 :                 info->section = SECTION_DATA;
    6933       12968 :                 break;
    6934        5640 :             case RELKIND_INDEX:
    6935             :             case RELKIND_PARTITIONED_INDEX:
    6936        5640 :                 info->section = SECTION_POST_DATA;
    6937        5640 :                 break;
    6938           0 :             default:
    6939           0 :                 pg_fatal("cannot dump statistics for relation kind '%c'",
    6940             :                          info->relkind);
    6941             :         }
    6942             : 
    6943       18608 :         return info;
    6944             :     }
    6945        2128 :     return NULL;
    6946             : }
    6947             : 
    6948             : /*
    6949             :  * getTables
    6950             :  *    read all the tables (no indexes) in the system catalogs,
    6951             :  *    and return them as an array of TableInfo structures
    6952             :  *
    6953             :  * *numTables is set to the number of tables read in
    6954             :  */
    6955             : TableInfo *
    6956         470 : getTables(Archive *fout, int *numTables)
    6957             : {
    6958         470 :     DumpOptions *dopt = fout->dopt;
    6959             :     PGresult   *res;
    6960             :     int         ntups;
    6961             :     int         i;
    6962         470 :     PQExpBuffer query = createPQExpBuffer();
    6963             :     TableInfo  *tblinfo;
    6964             :     int         i_reltableoid;
    6965             :     int         i_reloid;
    6966             :     int         i_relname;
    6967             :     int         i_relnamespace;
    6968             :     int         i_relkind;
    6969             :     int         i_reltype;
    6970             :     int         i_relowner;
    6971             :     int         i_relchecks;
    6972             :     int         i_relhasindex;
    6973             :     int         i_relhasrules;
    6974             :     int         i_relpages;
    6975             :     int         i_reltuples;
    6976             :     int         i_relallvisible;
    6977             :     int         i_relallfrozen;
    6978             :     int         i_toastpages;
    6979             :     int         i_owning_tab;
    6980             :     int         i_owning_col;
    6981             :     int         i_reltablespace;
    6982             :     int         i_relhasoids;
    6983             :     int         i_relhastriggers;
    6984             :     int         i_relpersistence;
    6985             :     int         i_relispopulated;
    6986             :     int         i_relreplident;
    6987             :     int         i_relrowsec;
    6988             :     int         i_relforcerowsec;
    6989             :     int         i_relfrozenxid;
    6990             :     int         i_toastfrozenxid;
    6991             :     int         i_toastoid;
    6992             :     int         i_relminmxid;
    6993             :     int         i_toastminmxid;
    6994             :     int         i_reloptions;
    6995             :     int         i_checkoption;
    6996             :     int         i_toastreloptions;
    6997             :     int         i_reloftype;
    6998             :     int         i_foreignserver;
    6999             :     int         i_amname;
    7000             :     int         i_is_identity_sequence;
    7001             :     int         i_relacl;
    7002             :     int         i_acldefault;
    7003             :     int         i_ispartition;
    7004             : 
    7005             :     /*
    7006             :      * Find all the tables and table-like objects.
    7007             :      *
    7008             :      * We must fetch all tables in this phase because otherwise we cannot
    7009             :      * correctly identify inherited columns, owned sequences, etc.
    7010             :      *
    7011             :      * We include system catalogs, so that we can work if a user table is
    7012             :      * defined to inherit from a system catalog (pretty weird, but...)
    7013             :      *
    7014             :      * Note: in this phase we should collect only a minimal amount of
    7015             :      * information about each table, basically just enough to decide if it is
    7016             :      * interesting.  In particular, since we do not yet have lock on any user
    7017             :      * table, we MUST NOT invoke any server-side data collection functions
    7018             :      * (for instance, pg_get_partkeydef()).  Those are likely to fail or give
    7019             :      * wrong answers if any concurrent DDL is happening.
    7020             :      */
    7021             : 
    7022         470 :     appendPQExpBufferStr(query,
    7023             :                          "SELECT c.tableoid, c.oid, c.relname, "
    7024             :                          "c.relnamespace, c.relkind, c.reltype, "
    7025             :                          "c.relowner, "
    7026             :                          "c.relchecks, "
    7027             :                          "c.relhasindex, c.relhasrules, c.relpages, "
    7028             :                          "c.reltuples, c.relallvisible, ");
    7029             : 
    7030         470 :     if (fout->remoteVersion >= 180000)
    7031         470 :         appendPQExpBufferStr(query, "c.relallfrozen, ");
    7032             :     else
    7033           0 :         appendPQExpBufferStr(query, "0 AS relallfrozen, ");
    7034             : 
    7035         470 :     appendPQExpBufferStr(query,
    7036             :                          "c.relhastriggers, c.relpersistence, "
    7037             :                          "c.reloftype, "
    7038             :                          "c.relacl, "
    7039             :                          "acldefault(CASE WHEN c.relkind = " CppAsString2(RELKIND_SEQUENCE)
    7040             :                          " THEN 's'::\"char\" ELSE 'r'::\"char\" END, c.relowner) AS acldefault, "
    7041             :                          "CASE WHEN c.relkind = " CppAsString2(RELKIND_FOREIGN_TABLE) " THEN "
    7042             :                          "(SELECT ftserver FROM pg_catalog.pg_foreign_table WHERE ftrelid = c.oid) "
    7043             :                          "ELSE 0 END AS foreignserver, "
    7044             :                          "c.relfrozenxid, tc.relfrozenxid AS tfrozenxid, "
    7045             :                          "tc.oid AS toid, "
    7046             :                          "tc.relpages AS toastpages, "
    7047             :                          "tc.reloptions AS toast_reloptions, "
    7048             :                          "d.refobjid AS owning_tab, "
    7049             :                          "d.refobjsubid AS owning_col, "
    7050             :                          "tsp.spcname AS reltablespace, ");
    7051             : 
    7052         470 :     if (fout->remoteVersion >= 120000)
    7053         470 :         appendPQExpBufferStr(query,
    7054             :                              "false AS relhasoids, ");
    7055             :     else
    7056           0 :         appendPQExpBufferStr(query,
    7057             :                              "c.relhasoids, ");
    7058             : 
    7059         470 :     if (fout->remoteVersion >= 90300)
    7060         470 :         appendPQExpBufferStr(query,
    7061             :                              "c.relispopulated, ");
    7062             :     else
    7063           0 :         appendPQExpBufferStr(query,
    7064             :                              "'t' as relispopulated, ");
    7065             : 
    7066         470 :     if (fout->remoteVersion >= 90400)
    7067         470 :         appendPQExpBufferStr(query,
    7068             :                              "c.relreplident, ");
    7069             :     else
    7070           0 :         appendPQExpBufferStr(query,
    7071             :                              "'d' AS relreplident, ");
    7072             : 
    7073         470 :     if (fout->remoteVersion >= 90500)
    7074         470 :         appendPQExpBufferStr(query,
    7075             :                              "c.relrowsecurity, c.relforcerowsecurity, ");
    7076             :     else
    7077           0 :         appendPQExpBufferStr(query,
    7078             :                              "false AS relrowsecurity, "
    7079             :                              "false AS relforcerowsecurity, ");
    7080             : 
    7081         470 :     if (fout->remoteVersion >= 90300)
    7082         470 :         appendPQExpBufferStr(query,
    7083             :                              "c.relminmxid, tc.relminmxid AS tminmxid, ");
    7084             :     else
    7085           0 :         appendPQExpBufferStr(query,
    7086             :                              "0 AS relminmxid, 0 AS tminmxid, ");
    7087             : 
    7088         470 :     if (fout->remoteVersion >= 90300)
    7089         470 :         appendPQExpBufferStr(query,
    7090             :                              "array_remove(array_remove(c.reloptions,'check_option=local'),'check_option=cascaded') AS reloptions, "
    7091             :                              "CASE WHEN 'check_option=local' = ANY (c.reloptions) THEN 'LOCAL'::text "
    7092             :                              "WHEN 'check_option=cascaded' = ANY (c.reloptions) THEN 'CASCADED'::text ELSE NULL END AS checkoption, ");
    7093             :     else
    7094           0 :         appendPQExpBufferStr(query,
    7095             :                              "c.reloptions, NULL AS checkoption, ");
    7096             : 
    7097         470 :     if (fout->remoteVersion >= 90600)
    7098         470 :         appendPQExpBufferStr(query,
    7099             :                              "am.amname, ");
    7100             :     else
    7101           0 :         appendPQExpBufferStr(query,
    7102             :                              "NULL AS amname, ");
    7103             : 
    7104         470 :     if (fout->remoteVersion >= 90600)
    7105         470 :         appendPQExpBufferStr(query,
    7106             :                              "(d.deptype = 'i') IS TRUE AS is_identity_sequence, ");
    7107             :     else
    7108           0 :         appendPQExpBufferStr(query,
    7109             :                              "false AS is_identity_sequence, ");
    7110             : 
    7111         470 :     if (fout->remoteVersion >= 100000)
    7112         470 :         appendPQExpBufferStr(query,
    7113             :                              "c.relispartition AS ispartition ");
    7114             :     else
    7115           0 :         appendPQExpBufferStr(query,
    7116             :                              "false AS ispartition ");
    7117             : 
    7118             :     /*
    7119             :      * Left join to pg_depend to pick up dependency info linking sequences to
    7120             :      * their owning column, if any (note this dependency is AUTO except for
    7121             :      * identity sequences, where it's INTERNAL). Also join to pg_tablespace to
    7122             :      * collect the spcname.
    7123             :      */
    7124         470 :     appendPQExpBufferStr(query,
    7125             :                          "\nFROM pg_class c\n"
    7126             :                          "LEFT JOIN pg_depend d ON "
    7127             :                          "(c.relkind = " CppAsString2(RELKIND_SEQUENCE) " AND "
    7128             :                          "d.classid = 'pg_class'::regclass AND d.objid = c.oid AND "
    7129             :                          "d.objsubid = 0 AND "
    7130             :                          "d.refclassid = 'pg_class'::regclass AND d.deptype IN ('a', 'i'))\n"
    7131             :                          "LEFT JOIN pg_tablespace tsp ON (tsp.oid = c.reltablespace)\n");
    7132             : 
    7133             :     /*
    7134             :      * In 9.6 and up, left join to pg_am to pick up the amname.
    7135             :      */
    7136         470 :     if (fout->remoteVersion >= 90600)
    7137         470 :         appendPQExpBufferStr(query,
    7138             :                              "LEFT JOIN pg_am am ON (c.relam = am.oid)\n");
    7139             : 
    7140             :     /*
    7141             :      * We purposefully ignore toast OIDs for partitioned tables; the reason is
    7142             :      * that versions 10 and 11 have them, but later versions do not, so
    7143             :      * emitting them causes the upgrade to fail.
    7144             :      */
    7145         470 :     appendPQExpBufferStr(query,
    7146             :                          "LEFT JOIN pg_class tc ON (c.reltoastrelid = tc.oid"
    7147             :                          " AND tc.relkind = " CppAsString2(RELKIND_TOASTVALUE)
    7148             :                          " AND c.relkind <> " CppAsString2(RELKIND_PARTITIONED_TABLE) ")\n");
    7149             : 
    7150             :     /*
    7151             :      * Restrict to interesting relkinds (in particular, not indexes).  Not all
    7152             :      * relkinds are possible in older servers, but it's not worth the trouble
    7153             :      * to emit a version-dependent list.
    7154             :      *
    7155             :      * Composite-type table entries won't be dumped as such, but we have to
    7156             :      * make a DumpableObject for them so that we can track dependencies of the
    7157             :      * composite type (pg_depend entries for columns of the composite type
    7158             :      * link to the pg_class entry not the pg_type entry).
    7159             :      */
    7160         470 :     appendPQExpBufferStr(query,
    7161             :                          "WHERE c.relkind IN ("
    7162             :                          CppAsString2(RELKIND_RELATION) ", "
    7163             :                          CppAsString2(RELKIND_SEQUENCE) ", "
    7164             :                          CppAsString2(RELKIND_VIEW) ", "
    7165             :                          CppAsString2(RELKIND_COMPOSITE_TYPE) ", "
    7166             :                          CppAsString2(RELKIND_MATVIEW) ", "
    7167             :                          CppAsString2(RELKIND_FOREIGN_TABLE) ", "
    7168             :                          CppAsString2(RELKIND_PARTITIONED_TABLE) ")\n"
    7169             :                          "ORDER BY c.oid");
    7170             : 
    7171         470 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    7172             : 
    7173         470 :     ntups = PQntuples(res);
    7174             : 
    7175         470 :     *numTables = ntups;
    7176             : 
    7177             :     /*
    7178             :      * Extract data from result and lock dumpable tables.  We do the locking
    7179             :      * before anything else, to minimize the window wherein a table could
    7180             :      * disappear under us.
    7181             :      *
    7182             :      * Note that we have to save info about all tables here, even when dumping
    7183             :      * only one, because we don't yet know which tables might be inheritance
    7184             :      * ancestors of the target table.
    7185             :      */
    7186         470 :     tblinfo = (TableInfo *) pg_malloc0(ntups * sizeof(TableInfo));
    7187             : 
    7188         470 :     i_reltableoid = PQfnumber(res, "tableoid");
    7189         470 :     i_reloid = PQfnumber(res, "oid");
    7190         470 :     i_relname = PQfnumber(res, "relname");
    7191         470 :     i_relnamespace = PQfnumber(res, "relnamespace");
    7192         470 :     i_relkind = PQfnumber(res, "relkind");
    7193         470 :     i_reltype = PQfnumber(res, "reltype");
    7194         470 :     i_relowner = PQfnumber(res, "relowner");
    7195         470 :     i_relchecks = PQfnumber(res, "relchecks");
    7196         470 :     i_relhasindex = PQfnumber(res, "relhasindex");
    7197         470 :     i_relhasrules = PQfnumber(res, "relhasrules");
    7198         470 :     i_relpages = PQfnumber(res, "relpages");
    7199         470 :     i_reltuples = PQfnumber(res, "reltuples");
    7200         470 :     i_relallvisible = PQfnumber(res, "relallvisible");
    7201         470 :     i_relallfrozen = PQfnumber(res, "relallfrozen");
    7202         470 :     i_toastpages = PQfnumber(res, "toastpages");
    7203         470 :     i_owning_tab = PQfnumber(res, "owning_tab");
    7204         470 :     i_owning_col = PQfnumber(res, "owning_col");
    7205         470 :     i_reltablespace = PQfnumber(res, "reltablespace");
    7206         470 :     i_relhasoids = PQfnumber(res, "relhasoids");
    7207         470 :     i_relhastriggers = PQfnumber(res, "relhastriggers");
    7208         470 :     i_relpersistence = PQfnumber(res, "relpersistence");
    7209         470 :     i_relispopulated = PQfnumber(res, "relispopulated");
    7210         470 :     i_relreplident = PQfnumber(res, "relreplident");
    7211         470 :     i_relrowsec = PQfnumber(res, "relrowsecurity");
    7212         470 :     i_relforcerowsec = PQfnumber(res, "relforcerowsecurity");
    7213         470 :     i_relfrozenxid = PQfnumber(res, "relfrozenxid");
    7214         470 :     i_toastfrozenxid = PQfnumber(res, "tfrozenxid");
    7215         470 :     i_toastoid = PQfnumber(res, "toid");
    7216         470 :     i_relminmxid = PQfnumber(res, "relminmxid");
    7217         470 :     i_toastminmxid = PQfnumber(res, "tminmxid");
    7218         470 :     i_reloptions = PQfnumber(res, "reloptions");
    7219         470 :     i_checkoption = PQfnumber(res, "checkoption");
    7220         470 :     i_toastreloptions = PQfnumber(res, "toast_reloptions");
    7221         470 :     i_reloftype = PQfnumber(res, "reloftype");
    7222         470 :     i_foreignserver = PQfnumber(res, "foreignserver");
    7223         470 :     i_amname = PQfnumber(res, "amname");
    7224         470 :     i_is_identity_sequence = PQfnumber(res, "is_identity_sequence");
    7225         470 :     i_relacl = PQfnumber(res, "relacl");
    7226         470 :     i_acldefault = PQfnumber(res, "acldefault");
    7227         470 :     i_ispartition = PQfnumber(res, "ispartition");
    7228             : 
    7229         470 :     if (dopt->lockWaitTimeout)
    7230             :     {
    7231             :         /*
    7232             :          * Arrange to fail instead of waiting forever for a table lock.
    7233             :          *
    7234             :          * NB: this coding assumes that the only queries issued within the
    7235             :          * following loop are LOCK TABLEs; else the timeout may be undesirably
    7236             :          * applied to other things too.
    7237             :          */
    7238           4 :         resetPQExpBuffer(query);
    7239           4 :         appendPQExpBufferStr(query, "SET statement_timeout = ");
    7240           4 :         appendStringLiteralConn(query, dopt->lockWaitTimeout, GetConnection(fout));
    7241           4 :         ExecuteSqlStatement(fout, query->data);
    7242             :     }
    7243             : 
    7244         470 :     resetPQExpBuffer(query);
    7245             : 
    7246      123670 :     for (i = 0; i < ntups; i++)
    7247             :     {
    7248      123200 :         int32       relallvisible = atoi(PQgetvalue(res, i, i_relallvisible));
    7249      123200 :         int32       relallfrozen = atoi(PQgetvalue(res, i, i_relallfrozen));
    7250             : 
    7251      123200 :         tblinfo[i].dobj.objType = DO_TABLE;
    7252      123200 :         tblinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_reltableoid));
    7253      123200 :         tblinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_reloid));
    7254      123200 :         AssignDumpId(&tblinfo[i].dobj);
    7255      123200 :         tblinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_relname));
    7256      246400 :         tblinfo[i].dobj.namespace =
    7257      123200 :             findNamespace(atooid(PQgetvalue(res, i, i_relnamespace)));
    7258      123200 :         tblinfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_relacl));
    7259      123200 :         tblinfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    7260      123200 :         tblinfo[i].dacl.privtype = 0;
    7261      123200 :         tblinfo[i].dacl.initprivs = NULL;
    7262      123200 :         tblinfo[i].relkind = *(PQgetvalue(res, i, i_relkind));
    7263      123200 :         tblinfo[i].reltype = atooid(PQgetvalue(res, i, i_reltype));
    7264      123200 :         tblinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_relowner));
    7265      123200 :         tblinfo[i].ncheck = atoi(PQgetvalue(res, i, i_relchecks));
    7266      123200 :         tblinfo[i].hasindex = (strcmp(PQgetvalue(res, i, i_relhasindex), "t") == 0);
    7267      123200 :         tblinfo[i].hasrules = (strcmp(PQgetvalue(res, i, i_relhasrules), "t") == 0);
    7268      123200 :         tblinfo[i].relpages = atoi(PQgetvalue(res, i, i_relpages));
    7269      123200 :         if (PQgetisnull(res, i, i_toastpages))
    7270       97752 :             tblinfo[i].toastpages = 0;
    7271             :         else
    7272       25448 :             tblinfo[i].toastpages = atoi(PQgetvalue(res, i, i_toastpages));
    7273      123200 :         if (PQgetisnull(res, i, i_owning_tab))
    7274             :         {
    7275      122130 :             tblinfo[i].owning_tab = InvalidOid;
    7276      122130 :             tblinfo[i].owning_col = 0;
    7277             :         }
    7278             :         else
    7279             :         {
    7280        1070 :             tblinfo[i].owning_tab = atooid(PQgetvalue(res, i, i_owning_tab));
    7281        1070 :             tblinfo[i].owning_col = atoi(PQgetvalue(res, i, i_owning_col));
    7282             :         }
    7283      123200 :         tblinfo[i].reltablespace = pg_strdup(PQgetvalue(res, i, i_reltablespace));
    7284      123200 :         tblinfo[i].hasoids = (strcmp(PQgetvalue(res, i, i_relhasoids), "t") == 0);
    7285      123200 :         tblinfo[i].hastriggers = (strcmp(PQgetvalue(res, i, i_relhastriggers), "t") == 0);
    7286      123200 :         tblinfo[i].relpersistence = *(PQgetvalue(res, i, i_relpersistence));
    7287      123200 :         tblinfo[i].relispopulated = (strcmp(PQgetvalue(res, i, i_relispopulated), "t") == 0);
    7288      123200 :         tblinfo[i].relreplident = *(PQgetvalue(res, i, i_relreplident));
    7289      123200 :         tblinfo[i].rowsec = (strcmp(PQgetvalue(res, i, i_relrowsec), "t") == 0);
    7290      123200 :         tblinfo[i].forcerowsec = (strcmp(PQgetvalue(res, i, i_relforcerowsec), "t") == 0);
    7291      123200 :         tblinfo[i].frozenxid = atooid(PQgetvalue(res, i, i_relfrozenxid));
    7292      123200 :         tblinfo[i].toast_frozenxid = atooid(PQgetvalue(res, i, i_toastfrozenxid));
    7293      123200 :         tblinfo[i].toast_oid = atooid(PQgetvalue(res, i, i_toastoid));
    7294      123200 :         tblinfo[i].minmxid = atooid(PQgetvalue(res, i, i_relminmxid));
    7295      123200 :         tblinfo[i].toast_minmxid = atooid(PQgetvalue(res, i, i_toastminmxid));
    7296      123200 :         tblinfo[i].reloptions = pg_strdup(PQgetvalue(res, i, i_reloptions));
    7297      123200 :         if (PQgetisnull(res, i, i_checkoption))
    7298      123100 :             tblinfo[i].checkoption = NULL;
    7299             :         else
    7300         100 :             tblinfo[i].checkoption = pg_strdup(PQgetvalue(res, i, i_checkoption));
    7301      123200 :         tblinfo[i].toast_reloptions = pg_strdup(PQgetvalue(res, i, i_toastreloptions));
    7302      123200 :         tblinfo[i].reloftype = atooid(PQgetvalue(res, i, i_reloftype));
    7303      123200 :         tblinfo[i].foreign_server = atooid(PQgetvalue(res, i, i_foreignserver));
    7304      123200 :         if (PQgetisnull(res, i, i_amname))
    7305       73414 :             tblinfo[i].amname = NULL;
    7306             :         else
    7307       49786 :             tblinfo[i].amname = pg_strdup(PQgetvalue(res, i, i_amname));
    7308      123200 :         tblinfo[i].is_identity_sequence = (strcmp(PQgetvalue(res, i, i_is_identity_sequence), "t") == 0);
    7309      123200 :         tblinfo[i].ispartition = (strcmp(PQgetvalue(res, i, i_ispartition), "t") == 0);
    7310             : 
    7311             :         /* other fields were zeroed above */
    7312             : 
    7313             :         /*
    7314             :          * Decide whether we want to dump this table.
    7315             :          */
    7316      123200 :         if (tblinfo[i].relkind == RELKIND_COMPOSITE_TYPE)
    7317         470 :             tblinfo[i].dobj.dump = DUMP_COMPONENT_NONE;
    7318             :         else
    7319      122730 :             selectDumpableTable(&tblinfo[i], fout);
    7320             : 
    7321             :         /*
    7322             :          * Now, consider the table "interesting" if we need to dump its
    7323             :          * definition, data or its statistics.  Later on, we'll skip a lot of
    7324             :          * data collection for uninteresting tables.
    7325             :          *
    7326             :          * Note: the "interesting" flag will also be set by flagInhTables for
    7327             :          * parents of interesting tables, so that we collect necessary
    7328             :          * inheritance info even when the parents are not themselves being
    7329             :          * dumped.  This is the main reason why we need an "interesting" flag
    7330             :          * that's separate from the components-to-dump bitmask.
    7331             :          */
    7332      123200 :         tblinfo[i].interesting = (tblinfo[i].dobj.dump &
    7333             :                                   (DUMP_COMPONENT_DEFINITION |
    7334             :                                    DUMP_COMPONENT_DATA |
    7335      123200 :                                    DUMP_COMPONENT_STATISTICS)) != 0;
    7336             : 
    7337      123200 :         tblinfo[i].dummy_view = false;  /* might get set during sort */
    7338      123200 :         tblinfo[i].postponed_def = false;   /* might get set during sort */
    7339             : 
    7340             :         /* Tables have data */
    7341      123200 :         tblinfo[i].dobj.components |= DUMP_COMPONENT_DATA;
    7342             : 
    7343             :         /* Mark whether table has an ACL */
    7344      123200 :         if (!PQgetisnull(res, i, i_relacl))
    7345       98086 :             tblinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
    7346      123200 :         tblinfo[i].hascolumnACLs = false;   /* may get set later */
    7347             : 
    7348             :         /* Add statistics */
    7349      123200 :         if (tblinfo[i].interesting)
    7350             :         {
    7351             :             RelStatsInfo *stats;
    7352             : 
    7353       37844 :             stats = getRelationStatistics(fout, &tblinfo[i].dobj,
    7354       18922 :                                           tblinfo[i].relpages,
    7355             :                                           PQgetvalue(res, i, i_reltuples),
    7356             :                                           relallvisible, relallfrozen,
    7357       18922 :                                           tblinfo[i].relkind, NULL, 0);
    7358       18922 :             if (tblinfo[i].relkind == RELKIND_MATVIEW)
    7359         988 :                 tblinfo[i].stats = stats;
    7360             :         }
    7361             : 
    7362             :         /*
    7363             :          * Read-lock target tables to make sure they aren't DROPPED or altered
    7364             :          * in schema before we get around to dumping them.
    7365             :          *
    7366             :          * Note that we don't explicitly lock parents of the target tables; we
    7367             :          * assume our lock on the child is enough to prevent schema
    7368             :          * alterations to parent tables.
    7369             :          *
    7370             :          * NOTE: it'd be kinda nice to lock other relations too, not only
    7371             :          * plain or partitioned tables, but the backend doesn't presently
    7372             :          * allow that.
    7373             :          *
    7374             :          * We only need to lock the table for certain components; see
    7375             :          * pg_dump.h
    7376             :          */
    7377      123200 :         if ((tblinfo[i].dobj.dump & DUMP_COMPONENTS_REQUIRING_LOCK) &&
    7378       18922 :             (tblinfo[i].relkind == RELKIND_RELATION ||
    7379        5250 :              tblinfo[i].relkind == RELKIND_PARTITIONED_TABLE))
    7380             :         {
    7381             :             /*
    7382             :              * Tables are locked in batches.  When dumping from a remote
    7383             :              * server this can save a significant amount of time by reducing
    7384             :              * the number of round trips.
    7385             :              */
    7386       15330 :             if (query->len == 0)
    7387         316 :                 appendPQExpBuffer(query, "LOCK TABLE %s",
    7388         316 :                                   fmtQualifiedDumpable(&tblinfo[i]));
    7389             :             else
    7390             :             {
    7391       15014 :                 appendPQExpBuffer(query, ", %s",
    7392       15014 :                                   fmtQualifiedDumpable(&tblinfo[i]));
    7393             : 
    7394             :                 /* Arbitrarily end a batch when query length reaches 100K. */
    7395       15014 :                 if (query->len >= 100000)
    7396             :                 {
    7397             :                     /* Lock another batch of tables. */
    7398           0 :                     appendPQExpBufferStr(query, " IN ACCESS SHARE MODE");
    7399           0 :                     ExecuteSqlStatement(fout, query->data);
    7400           0 :                     resetPQExpBuffer(query);
    7401             :                 }
    7402             :             }
    7403             :         }
    7404             :     }
    7405             : 
    7406         470 :     if (query->len != 0)
    7407             :     {
    7408             :         /* Lock the tables in the last batch. */
    7409         316 :         appendPQExpBufferStr(query, " IN ACCESS SHARE MODE");
    7410         316 :         ExecuteSqlStatement(fout, query->data);
    7411             :     }
    7412             : 
    7413         468 :     if (dopt->lockWaitTimeout)
    7414             :     {
    7415           4 :         ExecuteSqlStatement(fout, "SET statement_timeout = 0");
    7416             :     }
    7417             : 
    7418         468 :     PQclear(res);
    7419             : 
    7420         468 :     destroyPQExpBuffer(query);
    7421             : 
    7422         468 :     return tblinfo;
    7423             : }
    7424             : 
    7425             : /*
    7426             :  * getOwnedSeqs
    7427             :  *    identify owned sequences and mark them as dumpable if owning table is
    7428             :  *
    7429             :  * We used to do this in getTables(), but it's better to do it after the
    7430             :  * index used by findTableByOid() has been set up.
    7431             :  */
    7432             : void
    7433         468 : getOwnedSeqs(Archive *fout, TableInfo tblinfo[], int numTables)
    7434             : {
    7435             :     int         i;
    7436             : 
    7437             :     /*
    7438             :      * Force sequences that are "owned" by table columns to be dumped whenever
    7439             :      * their owning table is being dumped.
    7440             :      */
    7441      123140 :     for (i = 0; i < numTables; i++)
    7442             :     {
    7443      122672 :         TableInfo  *seqinfo = &tblinfo[i];
    7444             :         TableInfo  *owning_tab;
    7445             : 
    7446      122672 :         if (!OidIsValid(seqinfo->owning_tab))
    7447      121608 :             continue;           /* not an owned sequence */
    7448             : 
    7449        1064 :         owning_tab = findTableByOid(seqinfo->owning_tab);
    7450        1064 :         if (owning_tab == NULL)
    7451           0 :             pg_fatal("failed sanity check, parent table with OID %u of sequence with OID %u not found",
    7452             :                      seqinfo->owning_tab, seqinfo->dobj.catId.oid);
    7453             : 
    7454             :         /*
    7455             :          * For an identity sequence, dump exactly the same components for the
    7456             :          * sequence as for the owning table.  This is important because we
    7457             :          * treat the identity sequence as an integral part of the table.  For
    7458             :          * example, there is not any DDL command that allows creation of such
    7459             :          * a sequence independently of the table.
    7460             :          *
    7461             :          * For other owned sequences such as serial sequences, we need to dump
    7462             :          * the components that are being dumped for the table and any
    7463             :          * components that the sequence is explicitly marked with.
    7464             :          *
    7465             :          * We can't simply use the set of components which are being dumped
    7466             :          * for the table as the table might be in an extension (and only the
    7467             :          * non-extension components, eg: ACLs if changed, security labels, and
    7468             :          * policies, are being dumped) while the sequence is not (and
    7469             :          * therefore the definition and other components should also be
    7470             :          * dumped).
    7471             :          *
    7472             :          * If the sequence is part of the extension then it should be properly
    7473             :          * marked by checkExtensionMembership() and this will be a no-op as
    7474             :          * the table will be equivalently marked.
    7475             :          */
    7476        1064 :         if (seqinfo->is_identity_sequence)
    7477         538 :             seqinfo->dobj.dump = owning_tab->dobj.dump;
    7478             :         else
    7479         526 :             seqinfo->dobj.dump |= owning_tab->dobj.dump;
    7480             : 
    7481             :         /* Make sure that necessary data is available if we're dumping it */
    7482        1064 :         if (seqinfo->dobj.dump != DUMP_COMPONENT_NONE)
    7483             :         {
    7484         872 :             seqinfo->interesting = true;
    7485         872 :             owning_tab->interesting = true;
    7486             :         }
    7487             :     }
    7488         468 : }
    7489             : 
    7490             : /*
    7491             :  * getInherits
    7492             :  *    read all the inheritance information
    7493             :  * from the system catalogs return them in the InhInfo* structure
    7494             :  *
    7495             :  * numInherits is set to the number of pairs read in
    7496             :  */
    7497             : InhInfo *
    7498         468 : getInherits(Archive *fout, int *numInherits)
    7499             : {
    7500             :     PGresult   *res;
    7501             :     int         ntups;
    7502             :     int         i;
    7503         468 :     PQExpBuffer query = createPQExpBuffer();
    7504             :     InhInfo    *inhinfo;
    7505             : 
    7506             :     int         i_inhrelid;
    7507             :     int         i_inhparent;
    7508             : 
    7509             :     /* find all the inheritance information */
    7510         468 :     appendPQExpBufferStr(query, "SELECT inhrelid, inhparent FROM pg_inherits");
    7511             : 
    7512         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    7513             : 
    7514         468 :     ntups = PQntuples(res);
    7515             : 
    7516         468 :     *numInherits = ntups;
    7517             : 
    7518         468 :     inhinfo = (InhInfo *) pg_malloc(ntups * sizeof(InhInfo));
    7519             : 
    7520         468 :     i_inhrelid = PQfnumber(res, "inhrelid");
    7521         468 :     i_inhparent = PQfnumber(res, "inhparent");
    7522             : 
    7523        8594 :     for (i = 0; i < ntups; i++)
    7524             :     {
    7525        8126 :         inhinfo[i].inhrelid = atooid(PQgetvalue(res, i, i_inhrelid));
    7526        8126 :         inhinfo[i].inhparent = atooid(PQgetvalue(res, i, i_inhparent));
    7527             :     }
    7528             : 
    7529         468 :     PQclear(res);
    7530             : 
    7531         468 :     destroyPQExpBuffer(query);
    7532             : 
    7533         468 :     return inhinfo;
    7534             : }
    7535             : 
    7536             : /*
    7537             :  * getPartitioningInfo
    7538             :  *    get information about partitioning
    7539             :  *
    7540             :  * For the most part, we only collect partitioning info about tables we
    7541             :  * intend to dump.  However, this function has to consider all partitioned
    7542             :  * tables in the database, because we need to know about parents of partitions
    7543             :  * we are going to dump even if the parents themselves won't be dumped.
    7544             :  *
    7545             :  * Specifically, what we need to know is whether each partitioned table
    7546             :  * has an "unsafe" partitioning scheme that requires us to force
    7547             :  * load-via-partition-root mode for its children.  Currently the only case
    7548             :  * for which we force that is hash partitioning on enum columns, since the
    7549             :  * hash codes depend on enum value OIDs which won't be replicated across
    7550             :  * dump-and-reload.  There are other cases in which load-via-partition-root
    7551             :  * might be necessary, but we expect users to cope with them.
    7552             :  */
    7553             : void
    7554         468 : getPartitioningInfo(Archive *fout)
    7555             : {
    7556             :     PQExpBuffer query;
    7557             :     PGresult   *res;
    7558             :     int         ntups;
    7559             : 
    7560             :     /* hash partitioning didn't exist before v11 */
    7561         468 :     if (fout->remoteVersion < 110000)
    7562           0 :         return;
    7563             :     /* needn't bother if not dumping data */
    7564         468 :     if (!fout->dopt->dumpData)
    7565          72 :         return;
    7566             : 
    7567         396 :     query = createPQExpBuffer();
    7568             : 
    7569             :     /*
    7570             :      * Unsafe partitioning schemes are exactly those for which hash enum_ops
    7571             :      * appears among the partition opclasses.  We needn't check partstrat.
    7572             :      *
    7573             :      * Note that this query may well retrieve info about tables we aren't
    7574             :      * going to dump and hence have no lock on.  That's okay since we need not
    7575             :      * invoke any unsafe server-side functions.
    7576             :      */
    7577         396 :     appendPQExpBufferStr(query,
    7578             :                          "SELECT partrelid FROM pg_partitioned_table WHERE\n"
    7579             :                          "(SELECT c.oid FROM pg_opclass c JOIN pg_am a "
    7580             :                          "ON c.opcmethod = a.oid\n"
    7581             :                          "WHERE opcname = 'enum_ops' "
    7582             :                          "AND opcnamespace = 'pg_catalog'::regnamespace "
    7583             :                          "AND amname = 'hash') = ANY(partclass)");
    7584             : 
    7585         396 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    7586             : 
    7587         396 :     ntups = PQntuples(res);
    7588             : 
    7589         400 :     for (int i = 0; i < ntups; i++)
    7590             :     {
    7591           4 :         Oid         tabrelid = atooid(PQgetvalue(res, i, 0));
    7592             :         TableInfo  *tbinfo;
    7593             : 
    7594           4 :         tbinfo = findTableByOid(tabrelid);
    7595           4 :         if (tbinfo == NULL)
    7596           0 :             pg_fatal("failed sanity check, table OID %u appearing in pg_partitioned_table not found",
    7597             :                      tabrelid);
    7598           4 :         tbinfo->unsafe_partitions = true;
    7599             :     }
    7600             : 
    7601         396 :     PQclear(res);
    7602             : 
    7603         396 :     destroyPQExpBuffer(query);
    7604             : }
    7605             : 
    7606             : /*
    7607             :  * getIndexes
    7608             :  *    get information about every index on a dumpable table
    7609             :  *
    7610             :  * Note: index data is not returned directly to the caller, but it
    7611             :  * does get entered into the DumpableObject tables.
    7612             :  */
    7613             : void
    7614         468 : getIndexes(Archive *fout, TableInfo tblinfo[], int numTables)
    7615             : {
    7616         468 :     PQExpBuffer query = createPQExpBuffer();
    7617         468 :     PQExpBuffer tbloids = createPQExpBuffer();
    7618             :     PGresult   *res;
    7619             :     int         ntups;
    7620             :     int         curtblindx;
    7621             :     IndxInfo   *indxinfo;
    7622             :     int         i_tableoid,
    7623             :                 i_oid,
    7624             :                 i_indrelid,
    7625             :                 i_indexname,
    7626             :                 i_relpages,
    7627             :                 i_reltuples,
    7628             :                 i_relallvisible,
    7629             :                 i_relallfrozen,
    7630             :                 i_parentidx,
    7631             :                 i_indexdef,
    7632             :                 i_indnkeyatts,
    7633             :                 i_indnatts,
    7634             :                 i_indkey,
    7635             :                 i_indisclustered,
    7636             :                 i_indisreplident,
    7637             :                 i_indnullsnotdistinct,
    7638             :                 i_contype,
    7639             :                 i_conname,
    7640             :                 i_condeferrable,
    7641             :                 i_condeferred,
    7642             :                 i_conperiod,
    7643             :                 i_contableoid,
    7644             :                 i_conoid,
    7645             :                 i_condef,
    7646             :                 i_indattnames,
    7647             :                 i_tablespace,
    7648             :                 i_indreloptions,
    7649             :                 i_indstatcols,
    7650             :                 i_indstatvals;
    7651             : 
    7652             :     /*
    7653             :      * We want to perform just one query against pg_index.  However, we
    7654             :      * mustn't try to select every row of the catalog and then sort it out on
    7655             :      * the client side, because some of the server-side functions we need
    7656             :      * would be unsafe to apply to tables we don't have lock on.  Hence, we
    7657             :      * build an array of the OIDs of tables we care about (and now have lock
    7658             :      * on!), and use a WHERE clause to constrain which rows are selected.
    7659             :      */
    7660         468 :     appendPQExpBufferChar(tbloids, '{');
    7661      123140 :     for (int i = 0; i < numTables; i++)
    7662             :     {
    7663      122672 :         TableInfo  *tbinfo = &tblinfo[i];
    7664             : 
    7665      122672 :         if (!tbinfo->hasindex)
    7666       86466 :             continue;
    7667             : 
    7668             :         /*
    7669             :          * We can ignore indexes of uninteresting tables.
    7670             :          */
    7671       36206 :         if (!tbinfo->interesting)
    7672       30710 :             continue;
    7673             : 
    7674             :         /* OK, we need info for this table */
    7675        5496 :         if (tbloids->len > 1) /* do we have more than the '{'? */
    7676        5326 :             appendPQExpBufferChar(tbloids, ',');
    7677        5496 :         appendPQExpBuffer(tbloids, "%u", tbinfo->dobj.catId.oid);
    7678             :     }
    7679         468 :     appendPQExpBufferChar(tbloids, '}');
    7680             : 
    7681         468 :     appendPQExpBufferStr(query,
    7682             :                          "SELECT t.tableoid, t.oid, i.indrelid, "
    7683             :                          "t.relname AS indexname, "
    7684             :                          "t.relpages, t.reltuples, t.relallvisible, ");
    7685             : 
    7686         468 :     if (fout->remoteVersion >= 180000)
    7687         468 :         appendPQExpBufferStr(query, "t.relallfrozen, ");
    7688             :     else
    7689           0 :         appendPQExpBufferStr(query, "0 AS relallfrozen, ");
    7690             : 
    7691         468 :     appendPQExpBufferStr(query,
    7692             :                          "pg_catalog.pg_get_indexdef(i.indexrelid) AS indexdef, "
    7693             :                          "i.indkey, i.indisclustered, "
    7694             :                          "c.contype, c.conname, "
    7695             :                          "c.condeferrable, c.condeferred, "
    7696             :                          "c.tableoid AS contableoid, "
    7697             :                          "c.oid AS conoid, "
    7698             :                          "pg_catalog.pg_get_constraintdef(c.oid, false) AS condef, "
    7699             :                          "CASE WHEN i.indexprs IS NOT NULL THEN "
    7700             :                          "(SELECT pg_catalog.array_agg(attname ORDER BY attnum)"
    7701             :                          "  FROM pg_catalog.pg_attribute "
    7702             :                          "  WHERE attrelid = i.indexrelid) "
    7703             :                          "ELSE NULL END AS indattnames, "
    7704             :                          "(SELECT spcname FROM pg_catalog.pg_tablespace s WHERE s.oid = t.reltablespace) AS tablespace, "
    7705             :                          "t.reloptions AS indreloptions, ");
    7706             : 
    7707             : 
    7708         468 :     if (fout->remoteVersion >= 90400)
    7709         468 :         appendPQExpBufferStr(query,
    7710             :                              "i.indisreplident, ");
    7711             :     else
    7712           0 :         appendPQExpBufferStr(query,
    7713             :                              "false AS indisreplident, ");
    7714             : 
    7715         468 :     if (fout->remoteVersion >= 110000)
    7716         468 :         appendPQExpBufferStr(query,
    7717             :                              "inh.inhparent AS parentidx, "
    7718             :                              "i.indnkeyatts AS indnkeyatts, "
    7719             :                              "i.indnatts AS indnatts, "
    7720             :                              "(SELECT pg_catalog.array_agg(attnum ORDER BY attnum) "
    7721             :                              "  FROM pg_catalog.pg_attribute "
    7722             :                              "  WHERE attrelid = i.indexrelid AND "
    7723             :                              "    attstattarget >= 0) AS indstatcols, "
    7724             :                              "(SELECT pg_catalog.array_agg(attstattarget ORDER BY attnum) "
    7725             :                              "  FROM pg_catalog.pg_attribute "
    7726             :                              "  WHERE attrelid = i.indexrelid AND "
    7727             :                              "    attstattarget >= 0) AS indstatvals, ");
    7728             :     else
    7729           0 :         appendPQExpBufferStr(query,
    7730             :                              "0 AS parentidx, "
    7731             :                              "i.indnatts AS indnkeyatts, "
    7732             :                              "i.indnatts AS indnatts, "
    7733             :                              "'' AS indstatcols, "
    7734             :                              "'' AS indstatvals, ");
    7735             : 
    7736         468 :     if (fout->remoteVersion >= 150000)
    7737         468 :         appendPQExpBufferStr(query,
    7738             :                              "i.indnullsnotdistinct, ");
    7739             :     else
    7740           0 :         appendPQExpBufferStr(query,
    7741             :                              "false AS indnullsnotdistinct, ");
    7742             : 
    7743         468 :     if (fout->remoteVersion >= 180000)
    7744         468 :         appendPQExpBufferStr(query,
    7745             :                              "c.conperiod ");
    7746             :     else
    7747           0 :         appendPQExpBufferStr(query,
    7748             :                              "NULL AS conperiod ");
    7749             : 
    7750             :     /*
    7751             :      * The point of the messy-looking outer join is to find a constraint that
    7752             :      * is related by an internal dependency link to the index. If we find one,
    7753             :      * create a CONSTRAINT entry linked to the INDEX entry.  We assume an
    7754             :      * index won't have more than one internal dependency.
    7755             :      *
    7756             :      * Note: the check on conrelid is redundant, but useful because that
    7757             :      * column is indexed while conindid is not.
    7758             :      */
    7759         468 :     if (fout->remoteVersion >= 110000)
    7760             :     {
    7761         468 :         appendPQExpBuffer(query,
    7762             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    7763             :                           "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
    7764             :                           "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
    7765             :                           "JOIN pg_catalog.pg_class t2 ON (t2.oid = i.indrelid) "
    7766             :                           "LEFT JOIN pg_catalog.pg_constraint c "
    7767             :                           "ON (i.indrelid = c.conrelid AND "
    7768             :                           "i.indexrelid = c.conindid AND "
    7769             :                           "c.contype IN ('p','u','x')) "
    7770             :                           "LEFT JOIN pg_catalog.pg_inherits inh "
    7771             :                           "ON (inh.inhrelid = indexrelid) "
    7772             :                           "WHERE (i.indisvalid OR t2.relkind = 'p') "
    7773             :                           "AND i.indisready "
    7774             :                           "ORDER BY i.indrelid, indexname",
    7775             :                           tbloids->data);
    7776             :     }
    7777             :     else
    7778             :     {
    7779             :         /*
    7780             :          * the test on indisready is necessary in 9.2, and harmless in
    7781             :          * earlier/later versions
    7782             :          */
    7783           0 :         appendPQExpBuffer(query,
    7784             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    7785             :                           "JOIN pg_catalog.pg_index i ON (src.tbloid = i.indrelid) "
    7786             :                           "JOIN pg_catalog.pg_class t ON (t.oid = i.indexrelid) "
    7787             :                           "LEFT JOIN pg_catalog.pg_constraint c "
    7788             :                           "ON (i.indrelid = c.conrelid AND "
    7789             :                           "i.indexrelid = c.conindid AND "
    7790             :                           "c.contype IN ('p','u','x')) "
    7791             :                           "WHERE i.indisvalid AND i.indisready "
    7792             :                           "ORDER BY i.indrelid, indexname",
    7793             :                           tbloids->data);
    7794             :     }
    7795             : 
    7796         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    7797             : 
    7798         468 :     ntups = PQntuples(res);
    7799             : 
    7800         468 :     i_tableoid = PQfnumber(res, "tableoid");
    7801         468 :     i_oid = PQfnumber(res, "oid");
    7802         468 :     i_indrelid = PQfnumber(res, "indrelid");
    7803         468 :     i_indexname = PQfnumber(res, "indexname");
    7804         468 :     i_relpages = PQfnumber(res, "relpages");
    7805         468 :     i_reltuples = PQfnumber(res, "reltuples");
    7806         468 :     i_relallvisible = PQfnumber(res, "relallvisible");
    7807         468 :     i_relallfrozen = PQfnumber(res, "relallfrozen");
    7808         468 :     i_parentidx = PQfnumber(res, "parentidx");
    7809         468 :     i_indexdef = PQfnumber(res, "indexdef");
    7810         468 :     i_indnkeyatts = PQfnumber(res, "indnkeyatts");
    7811         468 :     i_indnatts = PQfnumber(res, "indnatts");
    7812         468 :     i_indkey = PQfnumber(res, "indkey");
    7813         468 :     i_indisclustered = PQfnumber(res, "indisclustered");
    7814         468 :     i_indisreplident = PQfnumber(res, "indisreplident");
    7815         468 :     i_indnullsnotdistinct = PQfnumber(res, "indnullsnotdistinct");
    7816         468 :     i_contype = PQfnumber(res, "contype");
    7817         468 :     i_conname = PQfnumber(res, "conname");
    7818         468 :     i_condeferrable = PQfnumber(res, "condeferrable");
    7819         468 :     i_condeferred = PQfnumber(res, "condeferred");
    7820         468 :     i_conperiod = PQfnumber(res, "conperiod");
    7821         468 :     i_contableoid = PQfnumber(res, "contableoid");
    7822         468 :     i_conoid = PQfnumber(res, "conoid");
    7823         468 :     i_condef = PQfnumber(res, "condef");
    7824         468 :     i_indattnames = PQfnumber(res, "indattnames");
    7825         468 :     i_tablespace = PQfnumber(res, "tablespace");
    7826         468 :     i_indreloptions = PQfnumber(res, "indreloptions");
    7827         468 :     i_indstatcols = PQfnumber(res, "indstatcols");
    7828         468 :     i_indstatvals = PQfnumber(res, "indstatvals");
    7829             : 
    7830         468 :     indxinfo = (IndxInfo *) pg_malloc(ntups * sizeof(IndxInfo));
    7831             : 
    7832             :     /*
    7833             :      * Outer loop iterates once per table, not once per row.  Incrementing of
    7834             :      * j is handled by the inner loop.
    7835             :      */
    7836         468 :     curtblindx = -1;
    7837        5908 :     for (int j = 0; j < ntups;)
    7838             :     {
    7839        5440 :         Oid         indrelid = atooid(PQgetvalue(res, j, i_indrelid));
    7840        5440 :         TableInfo  *tbinfo = NULL;
    7841        5440 :         char      **indAttNames = NULL;
    7842        5440 :         int         nindAttNames = 0;
    7843             :         int         numinds;
    7844             : 
    7845             :         /* Count rows for this table */
    7846        6956 :         for (numinds = 1; numinds < ntups - j; numinds++)
    7847        6786 :             if (atooid(PQgetvalue(res, j + numinds, i_indrelid)) != indrelid)
    7848        5270 :                 break;
    7849             : 
    7850             :         /*
    7851             :          * Locate the associated TableInfo; we rely on tblinfo[] being in OID
    7852             :          * order.
    7853             :          */
    7854       53814 :         while (++curtblindx < numTables)
    7855             :         {
    7856       53814 :             tbinfo = &tblinfo[curtblindx];
    7857       53814 :             if (tbinfo->dobj.catId.oid == indrelid)
    7858        5440 :                 break;
    7859             :         }
    7860        5440 :         if (curtblindx >= numTables)
    7861           0 :             pg_fatal("unrecognized table OID %u", indrelid);
    7862             :         /* cross-check that we only got requested tables */
    7863        5440 :         if (!tbinfo->hasindex ||
    7864        5440 :             !tbinfo->interesting)
    7865           0 :             pg_fatal("unexpected index data for table \"%s\"",
    7866             :                      tbinfo->dobj.name);
    7867             : 
    7868             :         /* Save data for this table */
    7869        5440 :         tbinfo->indexes = indxinfo + j;
    7870        5440 :         tbinfo->numIndexes = numinds;
    7871             : 
    7872       12396 :         for (int c = 0; c < numinds; c++, j++)
    7873             :         {
    7874             :             char        contype;
    7875             :             char        indexkind;
    7876             :             RelStatsInfo *relstats;
    7877        6956 :             int32       relpages = atoi(PQgetvalue(res, j, i_relpages));
    7878        6956 :             int32       relallvisible = atoi(PQgetvalue(res, j, i_relallvisible));
    7879        6956 :             int32       relallfrozen = atoi(PQgetvalue(res, j, i_relallfrozen));
    7880             : 
    7881        6956 :             indxinfo[j].dobj.objType = DO_INDEX;
    7882        6956 :             indxinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
    7883        6956 :             indxinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
    7884        6956 :             AssignDumpId(&indxinfo[j].dobj);
    7885        6956 :             indxinfo[j].dobj.dump = tbinfo->dobj.dump;
    7886        6956 :             indxinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_indexname));
    7887        6956 :             indxinfo[j].dobj.namespace = tbinfo->dobj.namespace;
    7888        6956 :             indxinfo[j].indextable = tbinfo;
    7889        6956 :             indxinfo[j].indexdef = pg_strdup(PQgetvalue(res, j, i_indexdef));
    7890        6956 :             indxinfo[j].indnkeyattrs = atoi(PQgetvalue(res, j, i_indnkeyatts));
    7891        6956 :             indxinfo[j].indnattrs = atoi(PQgetvalue(res, j, i_indnatts));
    7892        6956 :             indxinfo[j].tablespace = pg_strdup(PQgetvalue(res, j, i_tablespace));
    7893        6956 :             indxinfo[j].indreloptions = pg_strdup(PQgetvalue(res, j, i_indreloptions));
    7894        6956 :             indxinfo[j].indstatcols = pg_strdup(PQgetvalue(res, j, i_indstatcols));
    7895        6956 :             indxinfo[j].indstatvals = pg_strdup(PQgetvalue(res, j, i_indstatvals));
    7896        6956 :             indxinfo[j].indkeys = (Oid *) pg_malloc(indxinfo[j].indnattrs * sizeof(Oid));
    7897        6956 :             parseOidArray(PQgetvalue(res, j, i_indkey),
    7898        6956 :                           indxinfo[j].indkeys, indxinfo[j].indnattrs);
    7899        6956 :             indxinfo[j].indisclustered = (PQgetvalue(res, j, i_indisclustered)[0] == 't');
    7900        6956 :             indxinfo[j].indisreplident = (PQgetvalue(res, j, i_indisreplident)[0] == 't');
    7901        6956 :             indxinfo[j].indnullsnotdistinct = (PQgetvalue(res, j, i_indnullsnotdistinct)[0] == 't');
    7902        6956 :             indxinfo[j].parentidx = atooid(PQgetvalue(res, j, i_parentidx));
    7903        6956 :             indxinfo[j].partattaches = (SimplePtrList)
    7904             :             {
    7905             :                 NULL, NULL
    7906             :             };
    7907             : 
    7908        6956 :             if (indxinfo[j].parentidx == 0)
    7909        5476 :                 indexkind = RELKIND_INDEX;
    7910             :             else
    7911        1480 :                 indexkind = RELKIND_PARTITIONED_INDEX;
    7912             : 
    7913        6956 :             if (!PQgetisnull(res, j, i_indattnames))
    7914             :             {
    7915         392 :                 if (!parsePGArray(PQgetvalue(res, j, i_indattnames),
    7916             :                                   &indAttNames, &nindAttNames))
    7917           0 :                     pg_fatal("could not parse %s array", "indattnames");
    7918             :             }
    7919             : 
    7920        6956 :             relstats = getRelationStatistics(fout, &indxinfo[j].dobj, relpages,
    7921             :                                              PQgetvalue(res, j, i_reltuples),
    7922             :                                              relallvisible, relallfrozen, indexkind,
    7923             :                                              indAttNames, nindAttNames);
    7924             : 
    7925        6956 :             contype = *(PQgetvalue(res, j, i_contype));
    7926        6956 :             if (contype == 'p' || contype == 'u' || contype == 'x')
    7927        3864 :             {
    7928             :                 /*
    7929             :                  * If we found a constraint matching the index, create an
    7930             :                  * entry for it.
    7931             :                  */
    7932             :                 ConstraintInfo *constrinfo;
    7933             : 
    7934        3864 :                 constrinfo = (ConstraintInfo *) pg_malloc(sizeof(ConstraintInfo));
    7935        3864 :                 constrinfo->dobj.objType = DO_CONSTRAINT;
    7936        3864 :                 constrinfo->dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid));
    7937        3864 :                 constrinfo->dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid));
    7938        3864 :                 AssignDumpId(&constrinfo->dobj);
    7939        3864 :                 constrinfo->dobj.dump = tbinfo->dobj.dump;
    7940        3864 :                 constrinfo->dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
    7941        3864 :                 constrinfo->dobj.namespace = tbinfo->dobj.namespace;
    7942        3864 :                 constrinfo->contable = tbinfo;
    7943        3864 :                 constrinfo->condomain = NULL;
    7944        3864 :                 constrinfo->contype = contype;
    7945        3864 :                 if (contype == 'x')
    7946          32 :                     constrinfo->condef = pg_strdup(PQgetvalue(res, j, i_condef));
    7947             :                 else
    7948        3832 :                     constrinfo->condef = NULL;
    7949        3864 :                 constrinfo->confrelid = InvalidOid;
    7950        3864 :                 constrinfo->conindex = indxinfo[j].dobj.dumpId;
    7951        3864 :                 constrinfo->condeferrable = *(PQgetvalue(res, j, i_condeferrable)) == 't';
    7952        3864 :                 constrinfo->condeferred = *(PQgetvalue(res, j, i_condeferred)) == 't';
    7953        3864 :                 constrinfo->conperiod = *(PQgetvalue(res, j, i_conperiod)) == 't';
    7954        3864 :                 constrinfo->conislocal = true;
    7955        3864 :                 constrinfo->separate = true;
    7956             : 
    7957        3864 :                 indxinfo[j].indexconstraint = constrinfo->dobj.dumpId;
    7958        3864 :                 if (relstats != NULL)
    7959        3212 :                     addObjectDependency(&relstats->dobj, constrinfo->dobj.dumpId);
    7960             :             }
    7961             :             else
    7962             :             {
    7963             :                 /* Plain secondary index */
    7964        3092 :                 indxinfo[j].indexconstraint = 0;
    7965             :             }
    7966             :         }
    7967             :     }
    7968             : 
    7969         468 :     PQclear(res);
    7970             : 
    7971         468 :     destroyPQExpBuffer(query);
    7972         468 :     destroyPQExpBuffer(tbloids);
    7973         468 : }
    7974             : 
    7975             : /*
    7976             :  * getExtendedStatistics
    7977             :  *    get information about extended-statistics objects.
    7978             :  *
    7979             :  * Note: extended statistics data is not returned directly to the caller, but
    7980             :  * it does get entered into the DumpableObject tables.
    7981             :  */
    7982             : void
    7983         468 : getExtendedStatistics(Archive *fout)
    7984             : {
    7985             :     PQExpBuffer query;
    7986             :     PGresult   *res;
    7987             :     StatsExtInfo *statsextinfo;
    7988             :     int         ntups;
    7989             :     int         i_tableoid;
    7990             :     int         i_oid;
    7991             :     int         i_stxname;
    7992             :     int         i_stxnamespace;
    7993             :     int         i_stxowner;
    7994             :     int         i_stxrelid;
    7995             :     int         i_stattarget;
    7996             :     int         i;
    7997             : 
    7998             :     /* Extended statistics were new in v10 */
    7999         468 :     if (fout->remoteVersion < 100000)
    8000           0 :         return;
    8001             : 
    8002         468 :     query = createPQExpBuffer();
    8003             : 
    8004         468 :     if (fout->remoteVersion < 130000)
    8005           0 :         appendPQExpBufferStr(query, "SELECT tableoid, oid, stxname, "
    8006             :                              "stxnamespace, stxowner, stxrelid, NULL AS stxstattarget "
    8007             :                              "FROM pg_catalog.pg_statistic_ext");
    8008             :     else
    8009         468 :         appendPQExpBufferStr(query, "SELECT tableoid, oid, stxname, "
    8010             :                              "stxnamespace, stxowner, stxrelid, stxstattarget "
    8011             :                              "FROM pg_catalog.pg_statistic_ext");
    8012             : 
    8013         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8014             : 
    8015         468 :     ntups = PQntuples(res);
    8016             : 
    8017         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8018         468 :     i_oid = PQfnumber(res, "oid");
    8019         468 :     i_stxname = PQfnumber(res, "stxname");
    8020         468 :     i_stxnamespace = PQfnumber(res, "stxnamespace");
    8021         468 :     i_stxowner = PQfnumber(res, "stxowner");
    8022         468 :     i_stxrelid = PQfnumber(res, "stxrelid");
    8023         468 :     i_stattarget = PQfnumber(res, "stxstattarget");
    8024             : 
    8025         468 :     statsextinfo = (StatsExtInfo *) pg_malloc(ntups * sizeof(StatsExtInfo));
    8026             : 
    8027         842 :     for (i = 0; i < ntups; i++)
    8028             :     {
    8029         374 :         statsextinfo[i].dobj.objType = DO_STATSEXT;
    8030         374 :         statsextinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8031         374 :         statsextinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8032         374 :         AssignDumpId(&statsextinfo[i].dobj);
    8033         374 :         statsextinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_stxname));
    8034         748 :         statsextinfo[i].dobj.namespace =
    8035         374 :             findNamespace(atooid(PQgetvalue(res, i, i_stxnamespace)));
    8036         374 :         statsextinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_stxowner));
    8037         748 :         statsextinfo[i].stattable =
    8038         374 :             findTableByOid(atooid(PQgetvalue(res, i, i_stxrelid)));
    8039         374 :         if (PQgetisnull(res, i, i_stattarget))
    8040         276 :             statsextinfo[i].stattarget = -1;
    8041             :         else
    8042          98 :             statsextinfo[i].stattarget = atoi(PQgetvalue(res, i, i_stattarget));
    8043             : 
    8044             :         /* Decide whether we want to dump it */
    8045         374 :         selectDumpableStatisticsObject(&(statsextinfo[i]), fout);
    8046             :     }
    8047             : 
    8048         468 :     PQclear(res);
    8049         468 :     destroyPQExpBuffer(query);
    8050             : }
    8051             : 
    8052             : /*
    8053             :  * getConstraints
    8054             :  *
    8055             :  * Get info about constraints on dumpable tables.
    8056             :  *
    8057             :  * Currently handles foreign keys only.
    8058             :  * Unique and primary key constraints are handled with indexes,
    8059             :  * while check constraints are processed in getTableAttrs().
    8060             :  */
    8061             : void
    8062         468 : getConstraints(Archive *fout, TableInfo tblinfo[], int numTables)
    8063             : {
    8064         468 :     PQExpBuffer query = createPQExpBuffer();
    8065         468 :     PQExpBuffer tbloids = createPQExpBuffer();
    8066             :     PGresult   *res;
    8067             :     int         ntups;
    8068             :     int         curtblindx;
    8069         468 :     TableInfo  *tbinfo = NULL;
    8070             :     ConstraintInfo *constrinfo;
    8071             :     int         i_contableoid,
    8072             :                 i_conoid,
    8073             :                 i_conrelid,
    8074             :                 i_conname,
    8075             :                 i_confrelid,
    8076             :                 i_conindid,
    8077             :                 i_condef;
    8078             : 
    8079             :     /*
    8080             :      * We want to perform just one query against pg_constraint.  However, we
    8081             :      * mustn't try to select every row of the catalog and then sort it out on
    8082             :      * the client side, because some of the server-side functions we need
    8083             :      * would be unsafe to apply to tables we don't have lock on.  Hence, we
    8084             :      * build an array of the OIDs of tables we care about (and now have lock
    8085             :      * on!), and use a WHERE clause to constrain which rows are selected.
    8086             :      */
    8087         468 :     appendPQExpBufferChar(tbloids, '{');
    8088      123140 :     for (int i = 0; i < numTables; i++)
    8089             :     {
    8090      122672 :         TableInfo  *tinfo = &tblinfo[i];
    8091             : 
    8092      122672 :         if (!(tinfo->dobj.dump & DUMP_COMPONENT_DEFINITION))
    8093      103844 :             continue;
    8094             : 
    8095             :         /* OK, we need info for this table */
    8096       18828 :         if (tbloids->len > 1) /* do we have more than the '{'? */
    8097       18510 :             appendPQExpBufferChar(tbloids, ',');
    8098       18828 :         appendPQExpBuffer(tbloids, "%u", tinfo->dobj.catId.oid);
    8099             :     }
    8100         468 :     appendPQExpBufferChar(tbloids, '}');
    8101             : 
    8102         468 :     appendPQExpBufferStr(query,
    8103             :                          "SELECT c.tableoid, c.oid, "
    8104             :                          "conrelid, conname, confrelid, ");
    8105         468 :     if (fout->remoteVersion >= 110000)
    8106         468 :         appendPQExpBufferStr(query, "conindid, ");
    8107             :     else
    8108           0 :         appendPQExpBufferStr(query, "0 AS conindid, ");
    8109         468 :     appendPQExpBuffer(query,
    8110             :                       "pg_catalog.pg_get_constraintdef(c.oid) AS condef\n"
    8111             :                       "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    8112             :                       "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
    8113             :                       "WHERE contype = 'f' ",
    8114             :                       tbloids->data);
    8115         468 :     if (fout->remoteVersion >= 110000)
    8116         468 :         appendPQExpBufferStr(query,
    8117             :                              "AND conparentid = 0 ");
    8118         468 :     appendPQExpBufferStr(query,
    8119             :                          "ORDER BY conrelid, conname");
    8120             : 
    8121         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8122             : 
    8123         468 :     ntups = PQntuples(res);
    8124             : 
    8125         468 :     i_contableoid = PQfnumber(res, "tableoid");
    8126         468 :     i_conoid = PQfnumber(res, "oid");
    8127         468 :     i_conrelid = PQfnumber(res, "conrelid");
    8128         468 :     i_conname = PQfnumber(res, "conname");
    8129         468 :     i_confrelid = PQfnumber(res, "confrelid");
    8130         468 :     i_conindid = PQfnumber(res, "conindid");
    8131         468 :     i_condef = PQfnumber(res, "condef");
    8132             : 
    8133         468 :     constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));
    8134             : 
    8135         468 :     curtblindx = -1;
    8136         940 :     for (int j = 0; j < ntups; j++)
    8137             :     {
    8138         472 :         Oid         conrelid = atooid(PQgetvalue(res, j, i_conrelid));
    8139             :         TableInfo  *reftable;
    8140             : 
    8141             :         /*
    8142             :          * Locate the associated TableInfo; we rely on tblinfo[] being in OID
    8143             :          * order.
    8144             :          */
    8145         472 :         if (tbinfo == NULL || tbinfo->dobj.catId.oid != conrelid)
    8146             :         {
    8147       34182 :             while (++curtblindx < numTables)
    8148             :             {
    8149       34182 :                 tbinfo = &tblinfo[curtblindx];
    8150       34182 :                 if (tbinfo->dobj.catId.oid == conrelid)
    8151         440 :                     break;
    8152             :             }
    8153         440 :             if (curtblindx >= numTables)
    8154           0 :                 pg_fatal("unrecognized table OID %u", conrelid);
    8155             :         }
    8156             : 
    8157         472 :         constrinfo[j].dobj.objType = DO_FK_CONSTRAINT;
    8158         472 :         constrinfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_contableoid));
    8159         472 :         constrinfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_conoid));
    8160         472 :         AssignDumpId(&constrinfo[j].dobj);
    8161         472 :         constrinfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
    8162         472 :         constrinfo[j].dobj.namespace = tbinfo->dobj.namespace;
    8163         472 :         constrinfo[j].contable = tbinfo;
    8164         472 :         constrinfo[j].condomain = NULL;
    8165         472 :         constrinfo[j].contype = 'f';
    8166         472 :         constrinfo[j].condef = pg_strdup(PQgetvalue(res, j, i_condef));
    8167         472 :         constrinfo[j].confrelid = atooid(PQgetvalue(res, j, i_confrelid));
    8168         472 :         constrinfo[j].conindex = 0;
    8169         472 :         constrinfo[j].condeferrable = false;
    8170         472 :         constrinfo[j].condeferred = false;
    8171         472 :         constrinfo[j].conislocal = true;
    8172         472 :         constrinfo[j].separate = true;
    8173             : 
    8174             :         /*
    8175             :          * Restoring an FK that points to a partitioned table requires that
    8176             :          * all partition indexes have been attached beforehand. Ensure that
    8177             :          * happens by making the constraint depend on each index partition
    8178             :          * attach object.
    8179             :          */
    8180         472 :         reftable = findTableByOid(constrinfo[j].confrelid);
    8181         472 :         if (reftable && reftable->relkind == RELKIND_PARTITIONED_TABLE)
    8182             :         {
    8183          64 :             Oid         indexOid = atooid(PQgetvalue(res, j, i_conindid));
    8184             : 
    8185          64 :             if (indexOid != InvalidOid)
    8186             :             {
    8187          64 :                 for (int k = 0; k < reftable->numIndexes; k++)
    8188             :                 {
    8189             :                     IndxInfo   *refidx;
    8190             : 
    8191             :                     /* not our index? */
    8192          64 :                     if (reftable->indexes[k].dobj.catId.oid != indexOid)
    8193           0 :                         continue;
    8194             : 
    8195          64 :                     refidx = &reftable->indexes[k];
    8196          64 :                     addConstrChildIdxDeps(&constrinfo[j].dobj, refidx);
    8197          64 :                     break;
    8198             :                 }
    8199             :             }
    8200             :         }
    8201             :     }
    8202             : 
    8203         468 :     PQclear(res);
    8204             : 
    8205         468 :     destroyPQExpBuffer(query);
    8206         468 :     destroyPQExpBuffer(tbloids);
    8207         468 : }
    8208             : 
    8209             : /*
    8210             :  * addConstrChildIdxDeps
    8211             :  *
    8212             :  * Recursive subroutine for getConstraints
    8213             :  *
    8214             :  * Given an object representing a foreign key constraint and an index on the
    8215             :  * partitioned table it references, mark the constraint object as dependent
    8216             :  * on the DO_INDEX_ATTACH object of each index partition, recursively
    8217             :  * drilling down to their partitions if any.  This ensures that the FK is not
    8218             :  * restored until the index is fully marked valid.
    8219             :  */
    8220             : static void
    8221         144 : addConstrChildIdxDeps(DumpableObject *dobj, const IndxInfo *refidx)
    8222             : {
    8223             :     SimplePtrListCell *cell;
    8224             : 
    8225             :     Assert(dobj->objType == DO_FK_CONSTRAINT);
    8226             : 
    8227         496 :     for (cell = refidx->partattaches.head; cell; cell = cell->next)
    8228             :     {
    8229         352 :         IndexAttachInfo *attach = (IndexAttachInfo *) cell->ptr;
    8230             : 
    8231         352 :         addObjectDependency(dobj, attach->dobj.dumpId);
    8232             : 
    8233         352 :         if (attach->partitionIdx->partattaches.head != NULL)
    8234          80 :             addConstrChildIdxDeps(dobj, attach->partitionIdx);
    8235             :     }
    8236         144 : }
    8237             : 
    8238             : /*
    8239             :  * getDomainConstraints
    8240             :  *
    8241             :  * Get info about constraints on a domain.
    8242             :  */
    8243             : static void
    8244         452 : getDomainConstraints(Archive *fout, TypeInfo *tyinfo)
    8245             : {
    8246             :     int         i;
    8247             :     ConstraintInfo *constrinfo;
    8248         452 :     PQExpBuffer query = createPQExpBuffer();
    8249             :     PGresult   *res;
    8250             :     int         i_tableoid,
    8251             :                 i_oid,
    8252             :                 i_conname,
    8253             :                 i_consrc;
    8254             :     int         ntups;
    8255             : 
    8256         452 :     if (!fout->is_prepared[PREPQUERY_GETDOMAINCONSTRAINTS])
    8257             :     {
    8258             :         /* Set up query for constraint-specific details */
    8259         100 :         appendPQExpBufferStr(query,
    8260             :                              "PREPARE getDomainConstraints(pg_catalog.oid) AS\n"
    8261             :                              "SELECT tableoid, oid, conname, "
    8262             :                              "pg_catalog.pg_get_constraintdef(oid) AS consrc, "
    8263             :                              "convalidated "
    8264             :                              "FROM pg_catalog.pg_constraint "
    8265             :                              "WHERE contypid = $1 AND contype = 'c' "
    8266             :                              "ORDER BY conname");
    8267             : 
    8268         100 :         ExecuteSqlStatement(fout, query->data);
    8269             : 
    8270         100 :         fout->is_prepared[PREPQUERY_GETDOMAINCONSTRAINTS] = true;
    8271             :     }
    8272             : 
    8273         452 :     printfPQExpBuffer(query,
    8274             :                       "EXECUTE getDomainConstraints('%u')",
    8275             :                       tyinfo->dobj.catId.oid);
    8276             : 
    8277         452 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8278             : 
    8279         452 :     ntups = PQntuples(res);
    8280             : 
    8281         452 :     i_tableoid = PQfnumber(res, "tableoid");
    8282         452 :     i_oid = PQfnumber(res, "oid");
    8283         452 :     i_conname = PQfnumber(res, "conname");
    8284         452 :     i_consrc = PQfnumber(res, "consrc");
    8285             : 
    8286         452 :     constrinfo = (ConstraintInfo *) pg_malloc(ntups * sizeof(ConstraintInfo));
    8287             : 
    8288         452 :     tyinfo->nDomChecks = ntups;
    8289         452 :     tyinfo->domChecks = constrinfo;
    8290             : 
    8291         760 :     for (i = 0; i < ntups; i++)
    8292             :     {
    8293         308 :         bool        validated = PQgetvalue(res, i, 4)[0] == 't';
    8294             : 
    8295         308 :         constrinfo[i].dobj.objType = DO_CONSTRAINT;
    8296         308 :         constrinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8297         308 :         constrinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8298         308 :         AssignDumpId(&constrinfo[i].dobj);
    8299         308 :         constrinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_conname));
    8300         308 :         constrinfo[i].dobj.namespace = tyinfo->dobj.namespace;
    8301         308 :         constrinfo[i].contable = NULL;
    8302         308 :         constrinfo[i].condomain = tyinfo;
    8303         308 :         constrinfo[i].contype = 'c';
    8304         308 :         constrinfo[i].condef = pg_strdup(PQgetvalue(res, i, i_consrc));
    8305         308 :         constrinfo[i].confrelid = InvalidOid;
    8306         308 :         constrinfo[i].conindex = 0;
    8307         308 :         constrinfo[i].condeferrable = false;
    8308         308 :         constrinfo[i].condeferred = false;
    8309         308 :         constrinfo[i].conislocal = true;
    8310             : 
    8311         308 :         constrinfo[i].separate = !validated;
    8312             : 
    8313             :         /*
    8314             :          * Make the domain depend on the constraint, ensuring it won't be
    8315             :          * output till any constraint dependencies are OK.  If the constraint
    8316             :          * has not been validated, it's going to be dumped after the domain
    8317             :          * anyway, so this doesn't matter.
    8318             :          */
    8319         308 :         if (validated)
    8320         308 :             addObjectDependency(&tyinfo->dobj,
    8321         308 :                                 constrinfo[i].dobj.dumpId);
    8322             :     }
    8323             : 
    8324         452 :     PQclear(res);
    8325             : 
    8326         452 :     destroyPQExpBuffer(query);
    8327         452 : }
    8328             : 
    8329             : /*
    8330             :  * getRules
    8331             :  *    get basic information about every rule in the system
    8332             :  */
    8333             : void
    8334         468 : getRules(Archive *fout)
    8335             : {
    8336             :     PGresult   *res;
    8337             :     int         ntups;
    8338             :     int         i;
    8339         468 :     PQExpBuffer query = createPQExpBuffer();
    8340             :     RuleInfo   *ruleinfo;
    8341             :     int         i_tableoid;
    8342             :     int         i_oid;
    8343             :     int         i_rulename;
    8344             :     int         i_ruletable;
    8345             :     int         i_ev_type;
    8346             :     int         i_is_instead;
    8347             :     int         i_ev_enabled;
    8348             : 
    8349         468 :     appendPQExpBufferStr(query, "SELECT "
    8350             :                          "tableoid, oid, rulename, "
    8351             :                          "ev_class AS ruletable, ev_type, is_instead, "
    8352             :                          "ev_enabled "
    8353             :                          "FROM pg_rewrite "
    8354             :                          "ORDER BY oid");
    8355             : 
    8356         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8357             : 
    8358         468 :     ntups = PQntuples(res);
    8359             : 
    8360         468 :     ruleinfo = (RuleInfo *) pg_malloc(ntups * sizeof(RuleInfo));
    8361             : 
    8362         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8363         468 :     i_oid = PQfnumber(res, "oid");
    8364         468 :     i_rulename = PQfnumber(res, "rulename");
    8365         468 :     i_ruletable = PQfnumber(res, "ruletable");
    8366         468 :     i_ev_type = PQfnumber(res, "ev_type");
    8367         468 :     i_is_instead = PQfnumber(res, "is_instead");
    8368         468 :     i_ev_enabled = PQfnumber(res, "ev_enabled");
    8369             : 
    8370       72282 :     for (i = 0; i < ntups; i++)
    8371             :     {
    8372             :         Oid         ruletableoid;
    8373             : 
    8374       71814 :         ruleinfo[i].dobj.objType = DO_RULE;
    8375       71814 :         ruleinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8376       71814 :         ruleinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8377       71814 :         AssignDumpId(&ruleinfo[i].dobj);
    8378       71814 :         ruleinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_rulename));
    8379       71814 :         ruletableoid = atooid(PQgetvalue(res, i, i_ruletable));
    8380       71814 :         ruleinfo[i].ruletable = findTableByOid(ruletableoid);
    8381       71814 :         if (ruleinfo[i].ruletable == NULL)
    8382           0 :             pg_fatal("failed sanity check, parent table with OID %u of pg_rewrite entry with OID %u not found",
    8383             :                      ruletableoid, ruleinfo[i].dobj.catId.oid);
    8384       71814 :         ruleinfo[i].dobj.namespace = ruleinfo[i].ruletable->dobj.namespace;
    8385       71814 :         ruleinfo[i].dobj.dump = ruleinfo[i].ruletable->dobj.dump;
    8386       71814 :         ruleinfo[i].ev_type = *(PQgetvalue(res, i, i_ev_type));
    8387       71814 :         ruleinfo[i].is_instead = *(PQgetvalue(res, i, i_is_instead)) == 't';
    8388       71814 :         ruleinfo[i].ev_enabled = *(PQgetvalue(res, i, i_ev_enabled));
    8389       71814 :         if (ruleinfo[i].ruletable)
    8390             :         {
    8391             :             /*
    8392             :              * If the table is a view or materialized view, force its ON
    8393             :              * SELECT rule to be sorted before the view itself --- this
    8394             :              * ensures that any dependencies for the rule affect the table's
    8395             :              * positioning. Other rules are forced to appear after their
    8396             :              * table.
    8397             :              */
    8398       71814 :             if ((ruleinfo[i].ruletable->relkind == RELKIND_VIEW ||
    8399        1800 :                  ruleinfo[i].ruletable->relkind == RELKIND_MATVIEW) &&
    8400       71154 :                 ruleinfo[i].ev_type == '1' && ruleinfo[i].is_instead)
    8401             :             {
    8402       70098 :                 addObjectDependency(&ruleinfo[i].ruletable->dobj,
    8403       70098 :                                     ruleinfo[i].dobj.dumpId);
    8404             :                 /* We'll merge the rule into CREATE VIEW, if possible */
    8405       70098 :                 ruleinfo[i].separate = false;
    8406             :             }
    8407             :             else
    8408             :             {
    8409        1716 :                 addObjectDependency(&ruleinfo[i].dobj,
    8410        1716 :                                     ruleinfo[i].ruletable->dobj.dumpId);
    8411        1716 :                 ruleinfo[i].separate = true;
    8412             :             }
    8413             :         }
    8414             :         else
    8415           0 :             ruleinfo[i].separate = true;
    8416             :     }
    8417             : 
    8418         468 :     PQclear(res);
    8419             : 
    8420         468 :     destroyPQExpBuffer(query);
    8421         468 : }
    8422             : 
    8423             : /*
    8424             :  * getTriggers
    8425             :  *    get information about every trigger on a dumpable table
    8426             :  *
    8427             :  * Note: trigger data is not returned directly to the caller, but it
    8428             :  * does get entered into the DumpableObject tables.
    8429             :  */
    8430             : void
    8431         468 : getTriggers(Archive *fout, TableInfo tblinfo[], int numTables)
    8432             : {
    8433         468 :     PQExpBuffer query = createPQExpBuffer();
    8434         468 :     PQExpBuffer tbloids = createPQExpBuffer();
    8435             :     PGresult   *res;
    8436             :     int         ntups;
    8437             :     int         curtblindx;
    8438             :     TriggerInfo *tginfo;
    8439             :     int         i_tableoid,
    8440             :                 i_oid,
    8441             :                 i_tgrelid,
    8442             :                 i_tgname,
    8443             :                 i_tgenabled,
    8444             :                 i_tgispartition,
    8445             :                 i_tgdef;
    8446             : 
    8447             :     /*
    8448             :      * We want to perform just one query against pg_trigger.  However, we
    8449             :      * mustn't try to select every row of the catalog and then sort it out on
    8450             :      * the client side, because some of the server-side functions we need
    8451             :      * would be unsafe to apply to tables we don't have lock on.  Hence, we
    8452             :      * build an array of the OIDs of tables we care about (and now have lock
    8453             :      * on!), and use a WHERE clause to constrain which rows are selected.
    8454             :      */
    8455         468 :     appendPQExpBufferChar(tbloids, '{');
    8456      123140 :     for (int i = 0; i < numTables; i++)
    8457             :     {
    8458      122672 :         TableInfo  *tbinfo = &tblinfo[i];
    8459             : 
    8460      122672 :         if (!tbinfo->hastriggers ||
    8461        2898 :             !(tbinfo->dobj.dump & DUMP_COMPONENT_DEFINITION))
    8462      120298 :             continue;
    8463             : 
    8464             :         /* OK, we need info for this table */
    8465        2374 :         if (tbloids->len > 1) /* do we have more than the '{'? */
    8466        2258 :             appendPQExpBufferChar(tbloids, ',');
    8467        2374 :         appendPQExpBuffer(tbloids, "%u", tbinfo->dobj.catId.oid);
    8468             :     }
    8469         468 :     appendPQExpBufferChar(tbloids, '}');
    8470             : 
    8471         468 :     if (fout->remoteVersion >= 150000)
    8472             :     {
    8473             :         /*
    8474             :          * NB: think not to use pretty=true in pg_get_triggerdef.  It could
    8475             :          * result in non-forward-compatible dumps of WHEN clauses due to
    8476             :          * under-parenthesization.
    8477             :          *
    8478             :          * NB: We need to see partition triggers in case the tgenabled flag
    8479             :          * has been changed from the parent.
    8480             :          */
    8481         468 :         appendPQExpBuffer(query,
    8482             :                           "SELECT t.tgrelid, t.tgname, "
    8483             :                           "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
    8484             :                           "t.tgenabled, t.tableoid, t.oid, "
    8485             :                           "t.tgparentid <> 0 AS tgispartition\n"
    8486             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    8487             :                           "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
    8488             :                           "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
    8489             :                           "WHERE ((NOT t.tgisinternal AND t.tgparentid = 0) "
    8490             :                           "OR t.tgenabled != u.tgenabled) "
    8491             :                           "ORDER BY t.tgrelid, t.tgname",
    8492             :                           tbloids->data);
    8493             :     }
    8494           0 :     else if (fout->remoteVersion >= 130000)
    8495             :     {
    8496             :         /*
    8497             :          * NB: think not to use pretty=true in pg_get_triggerdef.  It could
    8498             :          * result in non-forward-compatible dumps of WHEN clauses due to
    8499             :          * under-parenthesization.
    8500             :          *
    8501             :          * NB: We need to see tgisinternal triggers in partitions, in case the
    8502             :          * tgenabled flag has been changed from the parent.
    8503             :          */
    8504           0 :         appendPQExpBuffer(query,
    8505             :                           "SELECT t.tgrelid, t.tgname, "
    8506             :                           "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
    8507             :                           "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition\n"
    8508             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    8509             :                           "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
    8510             :                           "LEFT JOIN pg_catalog.pg_trigger u ON (u.oid = t.tgparentid) "
    8511             :                           "WHERE (NOT t.tgisinternal OR t.tgenabled != u.tgenabled) "
    8512             :                           "ORDER BY t.tgrelid, t.tgname",
    8513             :                           tbloids->data);
    8514             :     }
    8515           0 :     else if (fout->remoteVersion >= 110000)
    8516             :     {
    8517             :         /*
    8518             :          * NB: We need to see tgisinternal triggers in partitions, in case the
    8519             :          * tgenabled flag has been changed from the parent. No tgparentid in
    8520             :          * version 11-12, so we have to match them via pg_depend.
    8521             :          *
    8522             :          * See above about pretty=true in pg_get_triggerdef.
    8523             :          */
    8524           0 :         appendPQExpBuffer(query,
    8525             :                           "SELECT t.tgrelid, t.tgname, "
    8526             :                           "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
    8527             :                           "t.tgenabled, t.tableoid, t.oid, t.tgisinternal as tgispartition "
    8528             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    8529             :                           "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
    8530             :                           "LEFT JOIN pg_catalog.pg_depend AS d ON "
    8531             :                           " d.classid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
    8532             :                           " d.refclassid = 'pg_catalog.pg_trigger'::pg_catalog.regclass AND "
    8533             :                           " d.objid = t.oid "
    8534             :                           "LEFT JOIN pg_catalog.pg_trigger AS pt ON pt.oid = refobjid "
    8535             :                           "WHERE (NOT t.tgisinternal OR t.tgenabled != pt.tgenabled) "
    8536             :                           "ORDER BY t.tgrelid, t.tgname",
    8537             :                           tbloids->data);
    8538             :     }
    8539             :     else
    8540             :     {
    8541             :         /* See above about pretty=true in pg_get_triggerdef */
    8542           0 :         appendPQExpBuffer(query,
    8543             :                           "SELECT t.tgrelid, t.tgname, "
    8544             :                           "pg_catalog.pg_get_triggerdef(t.oid, false) AS tgdef, "
    8545             :                           "t.tgenabled, false as tgispartition, "
    8546             :                           "t.tableoid, t.oid "
    8547             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    8548             :                           "JOIN pg_catalog.pg_trigger t ON (src.tbloid = t.tgrelid) "
    8549             :                           "WHERE NOT tgisinternal "
    8550             :                           "ORDER BY t.tgrelid, t.tgname",
    8551             :                           tbloids->data);
    8552             :     }
    8553             : 
    8554         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8555             : 
    8556         468 :     ntups = PQntuples(res);
    8557             : 
    8558         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8559         468 :     i_oid = PQfnumber(res, "oid");
    8560         468 :     i_tgrelid = PQfnumber(res, "tgrelid");
    8561         468 :     i_tgname = PQfnumber(res, "tgname");
    8562         468 :     i_tgenabled = PQfnumber(res, "tgenabled");
    8563         468 :     i_tgispartition = PQfnumber(res, "tgispartition");
    8564         468 :     i_tgdef = PQfnumber(res, "tgdef");
    8565             : 
    8566         468 :     tginfo = (TriggerInfo *) pg_malloc(ntups * sizeof(TriggerInfo));
    8567             : 
    8568             :     /*
    8569             :      * Outer loop iterates once per table, not once per row.  Incrementing of
    8570             :      * j is handled by the inner loop.
    8571             :      */
    8572         468 :     curtblindx = -1;
    8573        1252 :     for (int j = 0; j < ntups;)
    8574             :     {
    8575         784 :         Oid         tgrelid = atooid(PQgetvalue(res, j, i_tgrelid));
    8576         784 :         TableInfo  *tbinfo = NULL;
    8577             :         int         numtrigs;
    8578             : 
    8579             :         /* Count rows for this table */
    8580        1476 :         for (numtrigs = 1; numtrigs < ntups - j; numtrigs++)
    8581        1360 :             if (atooid(PQgetvalue(res, j + numtrigs, i_tgrelid)) != tgrelid)
    8582         668 :                 break;
    8583             : 
    8584             :         /*
    8585             :          * Locate the associated TableInfo; we rely on tblinfo[] being in OID
    8586             :          * order.
    8587             :          */
    8588       39492 :         while (++curtblindx < numTables)
    8589             :         {
    8590       39492 :             tbinfo = &tblinfo[curtblindx];
    8591       39492 :             if (tbinfo->dobj.catId.oid == tgrelid)
    8592         784 :                 break;
    8593             :         }
    8594         784 :         if (curtblindx >= numTables)
    8595           0 :             pg_fatal("unrecognized table OID %u", tgrelid);
    8596             : 
    8597             :         /* Save data for this table */
    8598         784 :         tbinfo->triggers = tginfo + j;
    8599         784 :         tbinfo->numTriggers = numtrigs;
    8600             : 
    8601        2260 :         for (int c = 0; c < numtrigs; c++, j++)
    8602             :         {
    8603        1476 :             tginfo[j].dobj.objType = DO_TRIGGER;
    8604        1476 :             tginfo[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
    8605        1476 :             tginfo[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
    8606        1476 :             AssignDumpId(&tginfo[j].dobj);
    8607        1476 :             tginfo[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_tgname));
    8608        1476 :             tginfo[j].dobj.namespace = tbinfo->dobj.namespace;
    8609        1476 :             tginfo[j].tgtable = tbinfo;
    8610        1476 :             tginfo[j].tgenabled = *(PQgetvalue(res, j, i_tgenabled));
    8611        1476 :             tginfo[j].tgispartition = *(PQgetvalue(res, j, i_tgispartition)) == 't';
    8612        1476 :             tginfo[j].tgdef = pg_strdup(PQgetvalue(res, j, i_tgdef));
    8613             :         }
    8614             :     }
    8615             : 
    8616         468 :     PQclear(res);
    8617             : 
    8618         468 :     destroyPQExpBuffer(query);
    8619         468 :     destroyPQExpBuffer(tbloids);
    8620         468 : }
    8621             : 
    8622             : /*
    8623             :  * getEventTriggers
    8624             :  *    get information about event triggers
    8625             :  */
    8626             : void
    8627         468 : getEventTriggers(Archive *fout)
    8628             : {
    8629             :     int         i;
    8630             :     PQExpBuffer query;
    8631             :     PGresult   *res;
    8632             :     EventTriggerInfo *evtinfo;
    8633             :     int         i_tableoid,
    8634             :                 i_oid,
    8635             :                 i_evtname,
    8636             :                 i_evtevent,
    8637             :                 i_evtowner,
    8638             :                 i_evttags,
    8639             :                 i_evtfname,
    8640             :                 i_evtenabled;
    8641             :     int         ntups;
    8642             : 
    8643             :     /* Before 9.3, there are no event triggers */
    8644         468 :     if (fout->remoteVersion < 90300)
    8645           0 :         return;
    8646             : 
    8647         468 :     query = createPQExpBuffer();
    8648             : 
    8649         468 :     appendPQExpBufferStr(query,
    8650             :                          "SELECT e.tableoid, e.oid, evtname, evtenabled, "
    8651             :                          "evtevent, evtowner, "
    8652             :                          "array_to_string(array("
    8653             :                          "select quote_literal(x) "
    8654             :                          " from unnest(evttags) as t(x)), ', ') as evttags, "
    8655             :                          "e.evtfoid::regproc as evtfname "
    8656             :                          "FROM pg_event_trigger e "
    8657             :                          "ORDER BY e.oid");
    8658             : 
    8659         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8660             : 
    8661         468 :     ntups = PQntuples(res);
    8662             : 
    8663         468 :     evtinfo = (EventTriggerInfo *) pg_malloc(ntups * sizeof(EventTriggerInfo));
    8664             : 
    8665         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8666         468 :     i_oid = PQfnumber(res, "oid");
    8667         468 :     i_evtname = PQfnumber(res, "evtname");
    8668         468 :     i_evtevent = PQfnumber(res, "evtevent");
    8669         468 :     i_evtowner = PQfnumber(res, "evtowner");
    8670         468 :     i_evttags = PQfnumber(res, "evttags");
    8671         468 :     i_evtfname = PQfnumber(res, "evtfname");
    8672         468 :     i_evtenabled = PQfnumber(res, "evtenabled");
    8673             : 
    8674         586 :     for (i = 0; i < ntups; i++)
    8675             :     {
    8676         118 :         evtinfo[i].dobj.objType = DO_EVENT_TRIGGER;
    8677         118 :         evtinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8678         118 :         evtinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8679         118 :         AssignDumpId(&evtinfo[i].dobj);
    8680         118 :         evtinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_evtname));
    8681         118 :         evtinfo[i].evtname = pg_strdup(PQgetvalue(res, i, i_evtname));
    8682         118 :         evtinfo[i].evtevent = pg_strdup(PQgetvalue(res, i, i_evtevent));
    8683         118 :         evtinfo[i].evtowner = getRoleName(PQgetvalue(res, i, i_evtowner));
    8684         118 :         evtinfo[i].evttags = pg_strdup(PQgetvalue(res, i, i_evttags));
    8685         118 :         evtinfo[i].evtfname = pg_strdup(PQgetvalue(res, i, i_evtfname));
    8686         118 :         evtinfo[i].evtenabled = *(PQgetvalue(res, i, i_evtenabled));
    8687             : 
    8688             :         /* Decide whether we want to dump it */
    8689         118 :         selectDumpableObject(&(evtinfo[i].dobj), fout);
    8690             :     }
    8691             : 
    8692         468 :     PQclear(res);
    8693             : 
    8694         468 :     destroyPQExpBuffer(query);
    8695             : }
    8696             : 
    8697             : /*
    8698             :  * getProcLangs
    8699             :  *    get basic information about every procedural language in the system
    8700             :  *
    8701             :  * NB: this must run after getFuncs() because we assume we can do
    8702             :  * findFuncByOid().
    8703             :  */
    8704             : void
    8705         468 : getProcLangs(Archive *fout)
    8706             : {
    8707             :     PGresult   *res;
    8708             :     int         ntups;
    8709             :     int         i;
    8710         468 :     PQExpBuffer query = createPQExpBuffer();
    8711             :     ProcLangInfo *planginfo;
    8712             :     int         i_tableoid;
    8713             :     int         i_oid;
    8714             :     int         i_lanname;
    8715             :     int         i_lanpltrusted;
    8716             :     int         i_lanplcallfoid;
    8717             :     int         i_laninline;
    8718             :     int         i_lanvalidator;
    8719             :     int         i_lanacl;
    8720             :     int         i_acldefault;
    8721             :     int         i_lanowner;
    8722             : 
    8723         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, "
    8724             :                          "lanname, lanpltrusted, lanplcallfoid, "
    8725             :                          "laninline, lanvalidator, "
    8726             :                          "lanacl, "
    8727             :                          "acldefault('l', lanowner) AS acldefault, "
    8728             :                          "lanowner "
    8729             :                          "FROM pg_language "
    8730             :                          "WHERE lanispl "
    8731             :                          "ORDER BY oid");
    8732             : 
    8733         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8734             : 
    8735         468 :     ntups = PQntuples(res);
    8736             : 
    8737         468 :     planginfo = (ProcLangInfo *) pg_malloc(ntups * sizeof(ProcLangInfo));
    8738             : 
    8739         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8740         468 :     i_oid = PQfnumber(res, "oid");
    8741         468 :     i_lanname = PQfnumber(res, "lanname");
    8742         468 :     i_lanpltrusted = PQfnumber(res, "lanpltrusted");
    8743         468 :     i_lanplcallfoid = PQfnumber(res, "lanplcallfoid");
    8744         468 :     i_laninline = PQfnumber(res, "laninline");
    8745         468 :     i_lanvalidator = PQfnumber(res, "lanvalidator");
    8746         468 :     i_lanacl = PQfnumber(res, "lanacl");
    8747         468 :     i_acldefault = PQfnumber(res, "acldefault");
    8748         468 :     i_lanowner = PQfnumber(res, "lanowner");
    8749             : 
    8750        1034 :     for (i = 0; i < ntups; i++)
    8751             :     {
    8752         566 :         planginfo[i].dobj.objType = DO_PROCLANG;
    8753         566 :         planginfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8754         566 :         planginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8755         566 :         AssignDumpId(&planginfo[i].dobj);
    8756             : 
    8757         566 :         planginfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_lanname));
    8758         566 :         planginfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_lanacl));
    8759         566 :         planginfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
    8760         566 :         planginfo[i].dacl.privtype = 0;
    8761         566 :         planginfo[i].dacl.initprivs = NULL;
    8762         566 :         planginfo[i].lanpltrusted = *(PQgetvalue(res, i, i_lanpltrusted)) == 't';
    8763         566 :         planginfo[i].lanplcallfoid = atooid(PQgetvalue(res, i, i_lanplcallfoid));
    8764         566 :         planginfo[i].laninline = atooid(PQgetvalue(res, i, i_laninline));
    8765         566 :         planginfo[i].lanvalidator = atooid(PQgetvalue(res, i, i_lanvalidator));
    8766         566 :         planginfo[i].lanowner = getRoleName(PQgetvalue(res, i, i_lanowner));
    8767             : 
    8768             :         /* Decide whether we want to dump it */
    8769         566 :         selectDumpableProcLang(&(planginfo[i]), fout);
    8770             : 
    8771             :         /* Mark whether language has an ACL */
    8772         566 :         if (!PQgetisnull(res, i, i_lanacl))
    8773          98 :             planginfo[i].dobj.components |= DUMP_COMPONENT_ACL;
    8774             :     }
    8775             : 
    8776         468 :     PQclear(res);
    8777             : 
    8778         468 :     destroyPQExpBuffer(query);
    8779         468 : }
    8780             : 
    8781             : /*
    8782             :  * getCasts
    8783             :  *    get basic information about most casts in the system
    8784             :  *
    8785             :  * Skip casts from a range to its multirange, since we'll create those
    8786             :  * automatically.
    8787             :  */
    8788             : void
    8789         468 : getCasts(Archive *fout)
    8790             : {
    8791             :     PGresult   *res;
    8792             :     int         ntups;
    8793             :     int         i;
    8794         468 :     PQExpBuffer query = createPQExpBuffer();
    8795             :     CastInfo   *castinfo;
    8796             :     int         i_tableoid;
    8797             :     int         i_oid;
    8798             :     int         i_castsource;
    8799             :     int         i_casttarget;
    8800             :     int         i_castfunc;
    8801             :     int         i_castcontext;
    8802             :     int         i_castmethod;
    8803             : 
    8804         468 :     if (fout->remoteVersion >= 140000)
    8805             :     {
    8806         468 :         appendPQExpBufferStr(query, "SELECT tableoid, oid, "
    8807             :                              "castsource, casttarget, castfunc, castcontext, "
    8808             :                              "castmethod "
    8809             :                              "FROM pg_cast c "
    8810             :                              "WHERE NOT EXISTS ( "
    8811             :                              "SELECT 1 FROM pg_range r "
    8812             :                              "WHERE c.castsource = r.rngtypid "
    8813             :                              "AND c.casttarget = r.rngmultitypid "
    8814             :                              ") "
    8815             :                              "ORDER BY 3,4");
    8816             :     }
    8817             :     else
    8818             :     {
    8819           0 :         appendPQExpBufferStr(query, "SELECT tableoid, oid, "
    8820             :                              "castsource, casttarget, castfunc, castcontext, "
    8821             :                              "castmethod "
    8822             :                              "FROM pg_cast ORDER BY 3,4");
    8823             :     }
    8824             : 
    8825         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8826             : 
    8827         468 :     ntups = PQntuples(res);
    8828             : 
    8829         468 :     castinfo = (CastInfo *) pg_malloc(ntups * sizeof(CastInfo));
    8830             : 
    8831         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8832         468 :     i_oid = PQfnumber(res, "oid");
    8833         468 :     i_castsource = PQfnumber(res, "castsource");
    8834         468 :     i_casttarget = PQfnumber(res, "casttarget");
    8835         468 :     i_castfunc = PQfnumber(res, "castfunc");
    8836         468 :     i_castcontext = PQfnumber(res, "castcontext");
    8837         468 :     i_castmethod = PQfnumber(res, "castmethod");
    8838             : 
    8839      107858 :     for (i = 0; i < ntups; i++)
    8840             :     {
    8841             :         PQExpBufferData namebuf;
    8842             :         TypeInfo   *sTypeInfo;
    8843             :         TypeInfo   *tTypeInfo;
    8844             : 
    8845      107390 :         castinfo[i].dobj.objType = DO_CAST;
    8846      107390 :         castinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8847      107390 :         castinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8848      107390 :         AssignDumpId(&castinfo[i].dobj);
    8849      107390 :         castinfo[i].castsource = atooid(PQgetvalue(res, i, i_castsource));
    8850      107390 :         castinfo[i].casttarget = atooid(PQgetvalue(res, i, i_casttarget));
    8851      107390 :         castinfo[i].castfunc = atooid(PQgetvalue(res, i, i_castfunc));
    8852      107390 :         castinfo[i].castcontext = *(PQgetvalue(res, i, i_castcontext));
    8853      107390 :         castinfo[i].castmethod = *(PQgetvalue(res, i, i_castmethod));
    8854             : 
    8855             :         /*
    8856             :          * Try to name cast as concatenation of typnames.  This is only used
    8857             :          * for purposes of sorting.  If we fail to find either type, the name
    8858             :          * will be an empty string.
    8859             :          */
    8860      107390 :         initPQExpBuffer(&namebuf);
    8861      107390 :         sTypeInfo = findTypeByOid(castinfo[i].castsource);
    8862      107390 :         tTypeInfo = findTypeByOid(castinfo[i].casttarget);
    8863      107390 :         if (sTypeInfo && tTypeInfo)
    8864      107390 :             appendPQExpBuffer(&namebuf, "%s %s",
    8865             :                               sTypeInfo->dobj.name, tTypeInfo->dobj.name);
    8866      107390 :         castinfo[i].dobj.name = namebuf.data;
    8867             : 
    8868             :         /* Decide whether we want to dump it */
    8869      107390 :         selectDumpableCast(&(castinfo[i]), fout);
    8870             :     }
    8871             : 
    8872         468 :     PQclear(res);
    8873             : 
    8874         468 :     destroyPQExpBuffer(query);
    8875         468 : }
    8876             : 
    8877             : static char *
    8878         204 : get_language_name(Archive *fout, Oid langid)
    8879             : {
    8880             :     PQExpBuffer query;
    8881             :     PGresult   *res;
    8882             :     char       *lanname;
    8883             : 
    8884         204 :     query = createPQExpBuffer();
    8885         204 :     appendPQExpBuffer(query, "SELECT lanname FROM pg_language WHERE oid = %u", langid);
    8886         204 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
    8887         204 :     lanname = pg_strdup(fmtId(PQgetvalue(res, 0, 0)));
    8888         204 :     destroyPQExpBuffer(query);
    8889         204 :     PQclear(res);
    8890             : 
    8891         204 :     return lanname;
    8892             : }
    8893             : 
    8894             : /*
    8895             :  * getTransforms
    8896             :  *    get basic information about every transform in the system
    8897             :  */
    8898             : void
    8899         468 : getTransforms(Archive *fout)
    8900             : {
    8901             :     PGresult   *res;
    8902             :     int         ntups;
    8903             :     int         i;
    8904             :     PQExpBuffer query;
    8905             :     TransformInfo *transforminfo;
    8906             :     int         i_tableoid;
    8907             :     int         i_oid;
    8908             :     int         i_trftype;
    8909             :     int         i_trflang;
    8910             :     int         i_trffromsql;
    8911             :     int         i_trftosql;
    8912             : 
    8913             :     /* Transforms didn't exist pre-9.5 */
    8914         468 :     if (fout->remoteVersion < 90500)
    8915           0 :         return;
    8916             : 
    8917         468 :     query = createPQExpBuffer();
    8918             : 
    8919         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, "
    8920             :                          "trftype, trflang, trffromsql::oid, trftosql::oid "
    8921             :                          "FROM pg_transform "
    8922             :                          "ORDER BY 3,4");
    8923             : 
    8924         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    8925             : 
    8926         468 :     ntups = PQntuples(res);
    8927             : 
    8928         468 :     transforminfo = (TransformInfo *) pg_malloc(ntups * sizeof(TransformInfo));
    8929             : 
    8930         468 :     i_tableoid = PQfnumber(res, "tableoid");
    8931         468 :     i_oid = PQfnumber(res, "oid");
    8932         468 :     i_trftype = PQfnumber(res, "trftype");
    8933         468 :     i_trflang = PQfnumber(res, "trflang");
    8934         468 :     i_trffromsql = PQfnumber(res, "trffromsql");
    8935         468 :     i_trftosql = PQfnumber(res, "trftosql");
    8936             : 
    8937         586 :     for (i = 0; i < ntups; i++)
    8938             :     {
    8939             :         PQExpBufferData namebuf;
    8940             :         TypeInfo   *typeInfo;
    8941             :         char       *lanname;
    8942             : 
    8943         118 :         transforminfo[i].dobj.objType = DO_TRANSFORM;
    8944         118 :         transforminfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    8945         118 :         transforminfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    8946         118 :         AssignDumpId(&transforminfo[i].dobj);
    8947         118 :         transforminfo[i].trftype = atooid(PQgetvalue(res, i, i_trftype));
    8948         118 :         transforminfo[i].trflang = atooid(PQgetvalue(res, i, i_trflang));
    8949         118 :         transforminfo[i].trffromsql = atooid(PQgetvalue(res, i, i_trffromsql));
    8950         118 :         transforminfo[i].trftosql = atooid(PQgetvalue(res, i, i_trftosql));
    8951             : 
    8952             :         /*
    8953             :          * Try to name transform as concatenation of type and language name.
    8954             :          * This is only used for purposes of sorting.  If we fail to find
    8955             :          * either, the name will be an empty string.
    8956             :          */
    8957         118 :         initPQExpBuffer(&namebuf);
    8958         118 :         typeInfo = findTypeByOid(transforminfo[i].trftype);
    8959         118 :         lanname = get_language_name(fout, transforminfo[i].trflang);
    8960         118 :         if (typeInfo && lanname)
    8961         118 :             appendPQExpBuffer(&namebuf, "%s %s",
    8962             :                               typeInfo->dobj.name, lanname);
    8963         118 :         transforminfo[i].dobj.name = namebuf.data;
    8964         118 :         free(lanname);
    8965             : 
    8966             :         /* Decide whether we want to dump it */
    8967         118 :         selectDumpableObject(&(transforminfo[i].dobj), fout);
    8968             :     }
    8969             : 
    8970         468 :     PQclear(res);
    8971             : 
    8972         468 :     destroyPQExpBuffer(query);
    8973             : }
    8974             : 
    8975             : /*
    8976             :  * getTableAttrs -
    8977             :  *    for each interesting table, read info about its attributes
    8978             :  *    (names, types, default values, CHECK constraints, etc)
    8979             :  *
    8980             :  *  modifies tblinfo
    8981             :  */
    8982             : void
    8983         468 : getTableAttrs(Archive *fout, TableInfo *tblinfo, int numTables)
    8984             : {
    8985         468 :     DumpOptions *dopt = fout->dopt;
    8986         468 :     PQExpBuffer q = createPQExpBuffer();
    8987         468 :     PQExpBuffer tbloids = createPQExpBuffer();
    8988         468 :     PQExpBuffer checkoids = createPQExpBuffer();
    8989         468 :     PQExpBuffer invalidnotnulloids = NULL;
    8990             :     PGresult   *res;
    8991             :     int         ntups;
    8992             :     int         curtblindx;
    8993             :     int         i_attrelid;
    8994             :     int         i_attnum;
    8995             :     int         i_attname;
    8996             :     int         i_atttypname;
    8997             :     int         i_attstattarget;
    8998             :     int         i_attstorage;
    8999             :     int         i_typstorage;
    9000             :     int         i_attidentity;
    9001             :     int         i_attgenerated;
    9002             :     int         i_attisdropped;
    9003             :     int         i_attlen;
    9004             :     int         i_attalign;
    9005             :     int         i_attislocal;
    9006             :     int         i_notnull_name;
    9007             :     int         i_notnull_noinherit;
    9008             :     int         i_notnull_islocal;
    9009             :     int         i_notnull_invalidoid;
    9010             :     int         i_attoptions;
    9011             :     int         i_attcollation;
    9012             :     int         i_attcompression;
    9013             :     int         i_attfdwoptions;
    9014             :     int         i_attmissingval;
    9015             :     int         i_atthasdef;
    9016             : 
    9017             :     /*
    9018             :      * We want to perform just one query against pg_attribute, and then just
    9019             :      * one against pg_attrdef (for DEFAULTs) and two against pg_constraint
    9020             :      * (for CHECK constraints and for NOT NULL constraints).  However, we
    9021             :      * mustn't try to select every row of those catalogs and then sort it out
    9022             :      * on the client side, because some of the server-side functions we need
    9023             :      * would be unsafe to apply to tables we don't have lock on.  Hence, we
    9024             :      * build an array of the OIDs of tables we care about (and now have lock
    9025             :      * on!), and use a WHERE clause to constrain which rows are selected.
    9026             :      */
    9027         468 :     appendPQExpBufferChar(tbloids, '{');
    9028         468 :     appendPQExpBufferChar(checkoids, '{');
    9029      123140 :     for (int i = 0; i < numTables; i++)
    9030             :     {
    9031      122672 :         TableInfo  *tbinfo = &tblinfo[i];
    9032             : 
    9033             :         /* Don't bother to collect info for sequences */
    9034      122672 :         if (tbinfo->relkind == RELKIND_SEQUENCE)
    9035        1632 :             continue;
    9036             : 
    9037             :         /* Don't bother with uninteresting tables, either */
    9038      121040 :         if (!tbinfo->interesting)
    9039      103274 :             continue;
    9040             : 
    9041             :         /* OK, we need info for this table */
    9042       17766 :         if (tbloids->len > 1) /* do we have more than the '{'? */
    9043       17444 :             appendPQExpBufferChar(tbloids, ',');
    9044       17766 :         appendPQExpBuffer(tbloids, "%u", tbinfo->dobj.catId.oid);
    9045             : 
    9046       17766 :         if (tbinfo->ncheck > 0)
    9047             :         {
    9048             :             /* Also make a list of the ones with check constraints */
    9049        1362 :             if (checkoids->len > 1) /* do we have more than the '{'? */
    9050        1210 :                 appendPQExpBufferChar(checkoids, ',');
    9051        1362 :             appendPQExpBuffer(checkoids, "%u", tbinfo->dobj.catId.oid);
    9052             :         }
    9053             :     }
    9054         468 :     appendPQExpBufferChar(tbloids, '}');
    9055         468 :     appendPQExpBufferChar(checkoids, '}');
    9056             : 
    9057             :     /*
    9058             :      * Find all the user attributes and their types.
    9059             :      *
    9060             :      * Since we only want to dump COLLATE clauses for attributes whose
    9061             :      * collation is different from their type's default, we use a CASE here to
    9062             :      * suppress uninteresting attcollations cheaply.
    9063             :      */
    9064         468 :     appendPQExpBufferStr(q,
    9065             :                          "SELECT\n"
    9066             :                          "a.attrelid,\n"
    9067             :                          "a.attnum,\n"
    9068             :                          "a.attname,\n"
    9069             :                          "a.attstattarget,\n"
    9070             :                          "a.attstorage,\n"
    9071             :                          "t.typstorage,\n"
    9072             :                          "a.atthasdef,\n"
    9073             :                          "a.attisdropped,\n"
    9074             :                          "a.attlen,\n"
    9075             :                          "a.attalign,\n"
    9076             :                          "a.attislocal,\n"
    9077             :                          "pg_catalog.format_type(t.oid, a.atttypmod) AS atttypname,\n"
    9078             :                          "array_to_string(a.attoptions, ', ') AS attoptions,\n"
    9079             :                          "CASE WHEN a.attcollation <> t.typcollation "
    9080             :                          "THEN a.attcollation ELSE 0 END AS attcollation,\n"
    9081             :                          "pg_catalog.array_to_string(ARRAY("
    9082             :                          "SELECT pg_catalog.quote_ident(option_name) || "
    9083             :                          "' ' || pg_catalog.quote_literal(option_value) "
    9084             :                          "FROM pg_catalog.pg_options_to_table(attfdwoptions) "
    9085             :                          "ORDER BY option_name"
    9086             :                          "), E',\n    ') AS attfdwoptions,\n");
    9087             : 
    9088             :     /*
    9089             :      * Find out any NOT NULL markings for each column.  In 18 and up we read
    9090             :      * pg_constraint to obtain the constraint name.  notnull_noinherit is set
    9091             :      * according to the NO INHERIT property.  For versions prior to 18, we
    9092             :      * store an empty string as the name when a constraint is marked as
    9093             :      * attnotnull (this cues dumpTableSchema to print the NOT NULL clause
    9094             :      * without a name); also, such cases are never NO INHERIT.
    9095             :      *
    9096             :      * For invalid constraints, we need to store their OIDs for processing
    9097             :      * elsewhere, so we bring the pg_constraint.oid value when the constraint
    9098             :      * is invalid, and NULL otherwise.
    9099             :      *
    9100             :      * We track in notnull_islocal whether the constraint was defined directly
    9101             :      * in this table or via an ancestor, for binary upgrade.  flagInhAttrs
    9102             :      * might modify this later for servers older than 18; it's also in charge
    9103             :      * of determining the correct inhcount.
    9104             :      */
    9105         468 :     if (fout->remoteVersion >= 180000)
    9106         468 :         appendPQExpBufferStr(q,
    9107             :                              "co.conname AS notnull_name,\n"
    9108             :                              "CASE WHEN NOT co.convalidated THEN co.oid "
    9109             :                              "ELSE NULL END AS notnull_invalidoid,\n"
    9110             :                              "co.connoinherit AS notnull_noinherit,\n"
    9111             :                              "co.conislocal AS notnull_islocal,\n");
    9112             :     else
    9113           0 :         appendPQExpBufferStr(q,
    9114             :                              "CASE WHEN a.attnotnull THEN '' ELSE NULL END AS notnull_name,\n"
    9115             :                              "NULL AS notnull_invalidoid,\n"
    9116             :                              "false AS notnull_noinherit,\n"
    9117             :                              "a.attislocal AS notnull_islocal,\n");
    9118             : 
    9119         468 :     if (fout->remoteVersion >= 140000)
    9120         468 :         appendPQExpBufferStr(q,
    9121             :                              "a.attcompression AS attcompression,\n");
    9122             :     else
    9123           0 :         appendPQExpBufferStr(q,
    9124             :                              "'' AS attcompression,\n");
    9125             : 
    9126         468 :     if (fout->remoteVersion >= 100000)
    9127         468 :         appendPQExpBufferStr(q,
    9128             :                              "a.attidentity,\n");
    9129             :     else
    9130           0 :         appendPQExpBufferStr(q,
    9131             :                              "'' AS attidentity,\n");
    9132             : 
    9133         468 :     if (fout->remoteVersion >= 110000)
    9134         468 :         appendPQExpBufferStr(q,
    9135             :                              "CASE WHEN a.atthasmissing AND NOT a.attisdropped "
    9136             :                              "THEN a.attmissingval ELSE null END AS attmissingval,\n");
    9137             :     else
    9138           0 :         appendPQExpBufferStr(q,
    9139             :                              "NULL AS attmissingval,\n");
    9140             : 
    9141         468 :     if (fout->remoteVersion >= 120000)
    9142         468 :         appendPQExpBufferStr(q,
    9143             :                              "a.attgenerated\n");
    9144             :     else
    9145           0 :         appendPQExpBufferStr(q,
    9146             :                              "'' AS attgenerated\n");
    9147             : 
    9148             :     /* need left join to pg_type to not fail on dropped columns ... */
    9149         468 :     appendPQExpBuffer(q,
    9150             :                       "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    9151             :                       "JOIN pg_catalog.pg_attribute a ON (src.tbloid = a.attrelid) "
    9152             :                       "LEFT JOIN pg_catalog.pg_type t "
    9153             :                       "ON (a.atttypid = t.oid)\n",
    9154             :                       tbloids->data);
    9155             : 
    9156             :     /*
    9157             :      * In versions 18 and up, we need pg_constraint for explicit NOT NULL
    9158             :      * entries.  Also, we need to know if the NOT NULL for each column is
    9159             :      * backing a primary key.
    9160             :      */
    9161         468 :     if (fout->remoteVersion >= 180000)
    9162         468 :         appendPQExpBufferStr(q,
    9163             :                              " LEFT JOIN pg_catalog.pg_constraint co ON "
    9164             :                              "(a.attrelid = co.conrelid\n"
    9165             :                              "   AND co.contype = 'n' AND "
    9166             :                              "co.conkey = array[a.attnum])\n");
    9167             : 
    9168         468 :     appendPQExpBufferStr(q,
    9169             :                          "WHERE a.attnum > 0::pg_catalog.int2\n"
    9170             :                          "ORDER BY a.attrelid, a.attnum");
    9171             : 
    9172         468 :     res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);
    9173             : 
    9174         468 :     ntups = PQntuples(res);
    9175             : 
    9176         468 :     i_attrelid = PQfnumber(res, "attrelid");
    9177         468 :     i_attnum = PQfnumber(res, "attnum");
    9178         468 :     i_attname = PQfnumber(res, "attname");
    9179         468 :     i_atttypname = PQfnumber(res, "atttypname");
    9180         468 :     i_attstattarget = PQfnumber(res, "attstattarget");
    9181         468 :     i_attstorage = PQfnumber(res, "attstorage");
    9182         468 :     i_typstorage = PQfnumber(res, "typstorage");
    9183         468 :     i_attidentity = PQfnumber(res, "attidentity");
    9184         468 :     i_attgenerated = PQfnumber(res, "attgenerated");
    9185         468 :     i_attisdropped = PQfnumber(res, "attisdropped");
    9186         468 :     i_attlen = PQfnumber(res, "attlen");
    9187         468 :     i_attalign = PQfnumber(res, "attalign");
    9188         468 :     i_attislocal = PQfnumber(res, "attislocal");
    9189         468 :     i_notnull_name = PQfnumber(res, "notnull_name");
    9190         468 :     i_notnull_invalidoid = PQfnumber(res, "notnull_invalidoid");
    9191         468 :     i_notnull_noinherit = PQfnumber(res, "notnull_noinherit");
    9192         468 :     i_notnull_islocal = PQfnumber(res, "notnull_islocal");
    9193         468 :     i_attoptions = PQfnumber(res, "attoptions");
    9194         468 :     i_attcollation = PQfnumber(res, "attcollation");
    9195         468 :     i_attcompression = PQfnumber(res, "attcompression");
    9196         468 :     i_attfdwoptions = PQfnumber(res, "attfdwoptions");
    9197         468 :     i_attmissingval = PQfnumber(res, "attmissingval");
    9198         468 :     i_atthasdef = PQfnumber(res, "atthasdef");
    9199             : 
    9200             :     /* Within the next loop, we'll accumulate OIDs of tables with defaults */
    9201         468 :     resetPQExpBuffer(tbloids);
    9202         468 :     appendPQExpBufferChar(tbloids, '{');
    9203             : 
    9204             :     /*
    9205             :      * Outer loop iterates once per table, not once per row.  Incrementing of
    9206             :      * r is handled by the inner loop.
    9207             :      */
    9208         468 :     curtblindx = -1;
    9209       17908 :     for (int r = 0; r < ntups;)
    9210             :     {
    9211       17440 :         Oid         attrelid = atooid(PQgetvalue(res, r, i_attrelid));
    9212       17440 :         TableInfo  *tbinfo = NULL;
    9213             :         int         numatts;
    9214             :         bool        hasdefaults;
    9215             : 
    9216             :         /* Count rows for this table */
    9217       67580 :         for (numatts = 1; numatts < ntups - r; numatts++)
    9218       67264 :             if (atooid(PQgetvalue(res, r + numatts, i_attrelid)) != attrelid)
    9219       17124 :                 break;
    9220             : 
    9221             :         /*
    9222             :          * Locate the associated TableInfo; we rely on tblinfo[] being in OID
    9223             :          * order.
    9224             :          */
    9225       86038 :         while (++curtblindx < numTables)
    9226             :         {
    9227       86038 :             tbinfo = &tblinfo[curtblindx];
    9228       86038 :             if (tbinfo->dobj.catId.oid == attrelid)
    9229       17440 :                 break;
    9230             :         }
    9231       17440 :         if (curtblindx >= numTables)
    9232           0 :             pg_fatal("unrecognized table OID %u", attrelid);
    9233             :         /* cross-check that we only got requested tables */
    9234       17440 :         if (tbinfo->relkind == RELKIND_SEQUENCE ||
    9235       17440 :             !tbinfo->interesting)
    9236           0 :             pg_fatal("unexpected column data for table \"%s\"",
    9237             :                      tbinfo->dobj.name);
    9238             : 
    9239             :         /* Save data for this table */
    9240       17440 :         tbinfo->numatts = numatts;
    9241       17440 :         tbinfo->attnames = (char **) pg_malloc(numatts * sizeof(char *));
    9242       17440 :         tbinfo->atttypnames = (char **) pg_malloc(numatts * sizeof(char *));
    9243       17440 :         tbinfo->attstattarget = (int *) pg_malloc(numatts * sizeof(int));
    9244       17440 :         tbinfo->attstorage = (char *) pg_malloc(numatts * sizeof(char));
    9245       17440 :         tbinfo->typstorage = (char *) pg_malloc(numatts * sizeof(char));
    9246       17440 :         tbinfo->attidentity = (char *) pg_malloc(numatts * sizeof(char));
    9247       17440 :         tbinfo->attgenerated = (char *) pg_malloc(numatts * sizeof(char));
    9248       17440 :         tbinfo->attisdropped = (bool *) pg_malloc(numatts * sizeof(bool));
    9249       17440 :         tbinfo->attlen = (int *) pg_malloc(numatts * sizeof(int));
    9250       17440 :         tbinfo->attalign = (char *) pg_malloc(numatts * sizeof(char));
    9251       17440 :         tbinfo->attislocal = (bool *) pg_malloc(numatts * sizeof(bool));
    9252       17440 :         tbinfo->attoptions = (char **) pg_malloc(numatts * sizeof(char *));
    9253       17440 :         tbinfo->attcollation = (Oid *) pg_malloc(numatts * sizeof(Oid));
    9254       17440 :         tbinfo->attcompression = (char *) pg_malloc(numatts * sizeof(char));
    9255       17440 :         tbinfo->attfdwoptions = (char **) pg_malloc(numatts * sizeof(char *));
    9256       17440 :         tbinfo->attmissingval = (char **) pg_malloc(numatts * sizeof(char *));
    9257       17440 :         tbinfo->notnull_constrs = (char **) pg_malloc(numatts * sizeof(char *));
    9258       17440 :         tbinfo->notnull_noinh = (bool *) pg_malloc(numatts * sizeof(bool));
    9259       17440 :         tbinfo->notnull_islocal = (bool *) pg_malloc(numatts * sizeof(bool));
    9260       17440 :         tbinfo->attrdefs = (AttrDefInfo **) pg_malloc(numatts * sizeof(AttrDefInfo *));
    9261       17440 :         hasdefaults = false;
    9262             : 
    9263       85020 :         for (int j = 0; j < numatts; j++, r++)
    9264             :         {
    9265       67580 :             if (j + 1 != atoi(PQgetvalue(res, r, i_attnum)))
    9266           0 :                 pg_fatal("invalid column numbering in table \"%s\"",
    9267             :                          tbinfo->dobj.name);
    9268       67580 :             tbinfo->attnames[j] = pg_strdup(PQgetvalue(res, r, i_attname));
    9269       67580 :             tbinfo->atttypnames[j] = pg_strdup(PQgetvalue(res, r, i_atttypname));
    9270       67580 :             if (PQgetisnull(res, r, i_attstattarget))
    9271       67492 :                 tbinfo->attstattarget[j] = -1;
    9272             :             else
    9273          88 :                 tbinfo->attstattarget[j] = atoi(PQgetvalue(res, r, i_attstattarget));
    9274       67580 :             tbinfo->attstorage[j] = *(PQgetvalue(res, r, i_attstorage));
    9275       67580 :             tbinfo->typstorage[j] = *(PQgetvalue(res, r, i_typstorage));
    9276       67580 :             tbinfo->attidentity[j] = *(PQgetvalue(res, r, i_attidentity));
    9277       67580 :             tbinfo->attgenerated[j] = *(PQgetvalue(res, r, i_attgenerated));
    9278       67580 :             tbinfo->needs_override = tbinfo->needs_override || (tbinfo->attidentity[j] == ATTRIBUTE_IDENTITY_ALWAYS);
    9279       67580 :             tbinfo->attisdropped[j] = (PQgetvalue(res, r, i_attisdropped)[0] == 't');
    9280       67580 :             tbinfo->attlen[j] = atoi(PQgetvalue(res, r, i_attlen));
    9281       67580 :             tbinfo->attalign[j] = *(PQgetvalue(res, r, i_attalign));
    9282       67580 :             tbinfo->attislocal[j] = (PQgetvalue(res, r, i_attislocal)[0] == 't');
    9283             : 
    9284             :             /* Handle not-null constraint name and flags */
    9285       67580 :             determineNotNullFlags(fout, res, r,
    9286             :                                   tbinfo, j,
    9287             :                                   i_notnull_name,
    9288             :                                   i_notnull_invalidoid,
    9289             :                                   i_notnull_noinherit,
    9290             :                                   i_notnull_islocal,
    9291             :                                   &invalidnotnulloids);
    9292             : 
    9293       67580 :             tbinfo->attoptions[j] = pg_strdup(PQgetvalue(res, r, i_attoptions));
    9294       67580 :             tbinfo->attcollation[j] = atooid(PQgetvalue(res, r, i_attcollation));
    9295       67580 :             tbinfo->attcompression[j] = *(PQgetvalue(res, r, i_attcompression));
    9296       67580 :             tbinfo->attfdwoptions[j] = pg_strdup(PQgetvalue(res, r, i_attfdwoptions));
    9297       67580 :             tbinfo->attmissingval[j] = pg_strdup(PQgetvalue(res, r, i_attmissingval));
    9298       67580 :             tbinfo->attrdefs[j] = NULL; /* fix below */
    9299       67580 :             if (PQgetvalue(res, r, i_atthasdef)[0] == 't')
    9300        3404 :                 hasdefaults = true;
    9301             :         }
    9302             : 
    9303       17440 :         if (hasdefaults)
    9304             :         {
    9305             :             /* Collect OIDs of interesting tables that have defaults */
    9306        2582 :             if (tbloids->len > 1) /* do we have more than the '{'? */
    9307        2432 :                 appendPQExpBufferChar(tbloids, ',');
    9308        2582 :             appendPQExpBuffer(tbloids, "%u", tbinfo->dobj.catId.oid);
    9309             :         }
    9310             :     }
    9311             : 
    9312             :     /* If invalidnotnulloids has any data, finalize it */
    9313         468 :     if (invalidnotnulloids != NULL)
    9314         100 :         appendPQExpBufferChar(invalidnotnulloids, '}');
    9315             : 
    9316         468 :     PQclear(res);
    9317             : 
    9318             :     /*
    9319             :      * Now get info about column defaults.  This is skipped for a data-only
    9320             :      * dump, as it is only needed for table schemas.
    9321             :      */
    9322         468 :     if (dopt->dumpSchema && tbloids->len > 1)
    9323             :     {
    9324             :         AttrDefInfo *attrdefs;
    9325             :         int         numDefaults;
    9326         134 :         TableInfo  *tbinfo = NULL;
    9327             : 
    9328         134 :         pg_log_info("finding table default expressions");
    9329             : 
    9330         134 :         appendPQExpBufferChar(tbloids, '}');
    9331             : 
    9332         134 :         printfPQExpBuffer(q, "SELECT a.tableoid, a.oid, adrelid, adnum, "
    9333             :                           "pg_catalog.pg_get_expr(adbin, adrelid) AS adsrc\n"
    9334             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    9335             :                           "JOIN pg_catalog.pg_attrdef a ON (src.tbloid = a.adrelid)\n"
    9336             :                           "ORDER BY a.adrelid, a.adnum",
    9337             :                           tbloids->data);
    9338             : 
    9339         134 :         res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);
    9340             : 
    9341         134 :         numDefaults = PQntuples(res);
    9342         134 :         attrdefs = (AttrDefInfo *) pg_malloc(numDefaults * sizeof(AttrDefInfo));
    9343             : 
    9344         134 :         curtblindx = -1;
    9345        3342 :         for (int j = 0; j < numDefaults; j++)
    9346             :         {
    9347        3208 :             Oid         adtableoid = atooid(PQgetvalue(res, j, 0));
    9348        3208 :             Oid         adoid = atooid(PQgetvalue(res, j, 1));
    9349        3208 :             Oid         adrelid = atooid(PQgetvalue(res, j, 2));
    9350        3208 :             int         adnum = atoi(PQgetvalue(res, j, 3));
    9351        3208 :             char       *adsrc = PQgetvalue(res, j, 4);
    9352             : 
    9353             :             /*
    9354             :              * Locate the associated TableInfo; we rely on tblinfo[] being in
    9355             :              * OID order.
    9356             :              */
    9357        3208 :             if (tbinfo == NULL || tbinfo->dobj.catId.oid != adrelid)
    9358             :             {
    9359       45414 :                 while (++curtblindx < numTables)
    9360             :                 {
    9361       45414 :                     tbinfo = &tblinfo[curtblindx];
    9362       45414 :                     if (tbinfo->dobj.catId.oid == adrelid)
    9363        2446 :                         break;
    9364             :                 }
    9365        2446 :                 if (curtblindx >= numTables)
    9366           0 :                     pg_fatal("unrecognized table OID %u", adrelid);
    9367             :             }
    9368             : 
    9369        3208 :             if (adnum <= 0 || adnum > tbinfo->numatts)
    9370           0 :                 pg_fatal("invalid adnum value %d for table \"%s\"",
    9371             :                          adnum, tbinfo->dobj.name);
    9372             : 
    9373             :             /*
    9374             :              * dropped columns shouldn't have defaults, but just in case,
    9375             :              * ignore 'em
    9376             :              */
    9377        3208 :             if (tbinfo->attisdropped[adnum - 1])
    9378           0 :                 continue;
    9379             : 
    9380        3208 :             attrdefs[j].dobj.objType = DO_ATTRDEF;
    9381        3208 :             attrdefs[j].dobj.catId.tableoid = adtableoid;
    9382        3208 :             attrdefs[j].dobj.catId.oid = adoid;
    9383        3208 :             AssignDumpId(&attrdefs[j].dobj);
    9384        3208 :             attrdefs[j].adtable = tbinfo;
    9385        3208 :             attrdefs[j].adnum = adnum;
    9386        3208 :             attrdefs[j].adef_expr = pg_strdup(adsrc);
    9387             : 
    9388        3208 :             attrdefs[j].dobj.name = pg_strdup(tbinfo->dobj.name);
    9389        3208 :             attrdefs[j].dobj.namespace = tbinfo->dobj.namespace;
    9390             : 
    9391        3208 :             attrdefs[j].dobj.dump = tbinfo->dobj.dump;
    9392             : 
    9393             :             /*
    9394             :              * Figure out whether the default/generation expression should be
    9395             :              * dumped as part of the main CREATE TABLE (or similar) command or
    9396             :              * as a separate ALTER TABLE (or similar) command. The preference
    9397             :              * is to put it into the CREATE command, but in some cases that's
    9398             :              * not possible.
    9399             :              */
    9400        3208 :             if (tbinfo->attgenerated[adnum - 1])
    9401             :             {
    9402             :                 /*
    9403             :                  * Column generation expressions cannot be dumped separately,
    9404             :                  * because there is no syntax for it.  By setting separate to
    9405             :                  * false here we prevent the "default" from being processed as
    9406             :                  * its own dumpable object.  Later, flagInhAttrs() will mark
    9407             :                  * it as not to be dumped at all, if possible (that is, if it
    9408             :                  * can be inherited from a parent).
    9409             :                  */
    9410        1840 :                 attrdefs[j].separate = false;
    9411             :             }
    9412        1368 :             else if (tbinfo->relkind == RELKIND_VIEW)
    9413             :             {
    9414             :                 /*
    9415             :                  * Defaults on a VIEW must always be dumped as separate ALTER
    9416             :                  * TABLE commands.
    9417             :                  */
    9418          72 :                 attrdefs[j].separate = true;
    9419             :             }
    9420        1296 :             else if (!shouldPrintColumn(dopt, tbinfo, adnum - 1))
    9421             :             {
    9422             :                 /* column will be suppressed, print default separately */
    9423          14 :                 attrdefs[j].separate = true;
    9424             :             }
    9425             :             else
    9426             :             {
    9427        1282 :                 attrdefs[j].separate = false;
    9428             :             }
    9429             : 
    9430        3208 :             if (!attrdefs[j].separate)
    9431             :             {
    9432             :                 /*
    9433             :                  * Mark the default as needing to appear before the table, so
    9434             :                  * that any dependencies it has must be emitted before the
    9435             :                  * CREATE TABLE.  If this is not possible, we'll change to
    9436             :                  * "separate" mode while sorting dependencies.
    9437             :                  */
    9438        3122 :                 addObjectDependency(&tbinfo->dobj,
    9439        3122 :                                     attrdefs[j].dobj.dumpId);
    9440             :             }
    9441             : 
    9442        3208 :             tbinfo->attrdefs[adnum - 1] = &attrdefs[j];
    9443             :         }
    9444             : 
    9445         134 :         PQclear(res);
    9446             :     }
    9447             : 
    9448             :     /*
    9449             :      * Get info about NOT NULL NOT VALID constraints.  This is skipped for a
    9450             :      * data-only dump, as it is only needed for table schemas.
    9451             :      */
    9452         468 :     if (dopt->dumpSchema && invalidnotnulloids)
    9453             :     {
    9454             :         ConstraintInfo *constrs;
    9455             :         int         numConstrs;
    9456             :         int         i_tableoid;
    9457             :         int         i_oid;
    9458             :         int         i_conrelid;
    9459             :         int         i_conname;
    9460             :         int         i_consrc;
    9461             :         int         i_conislocal;
    9462             : 
    9463          88 :         pg_log_info("finding invalid not null constraints");
    9464             : 
    9465          88 :         resetPQExpBuffer(q);
    9466          88 :         appendPQExpBuffer(q,
    9467             :                           "SELECT c.tableoid, c.oid, conrelid, conname, "
    9468             :                           "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
    9469             :                           "conislocal, convalidated "
    9470             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(conoid)\n"
    9471             :                           "JOIN pg_catalog.pg_constraint c ON (src.conoid = c.oid)\n"
    9472             :                           "ORDER BY c.conrelid, c.conname",
    9473          88 :                           invalidnotnulloids->data);
    9474             : 
    9475          88 :         res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);
    9476             : 
    9477          88 :         numConstrs = PQntuples(res);
    9478          88 :         constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(ConstraintInfo));
    9479             : 
    9480          88 :         i_tableoid = PQfnumber(res, "tableoid");
    9481          88 :         i_oid = PQfnumber(res, "oid");
    9482          88 :         i_conrelid = PQfnumber(res, "conrelid");
    9483          88 :         i_conname = PQfnumber(res, "conname");
    9484          88 :         i_consrc = PQfnumber(res, "consrc");
    9485          88 :         i_conislocal = PQfnumber(res, "conislocal");
    9486             : 
    9487             :         /* As above, this loop iterates once per table, not once per row */
    9488          88 :         curtblindx = -1;
    9489         240 :         for (int j = 0; j < numConstrs;)
    9490             :         {
    9491         152 :             Oid         conrelid = atooid(PQgetvalue(res, j, i_conrelid));
    9492         152 :             TableInfo  *tbinfo = NULL;
    9493             :             int         numcons;
    9494             : 
    9495             :             /* Count rows for this table */
    9496         152 :             for (numcons = 1; numcons < numConstrs - j; numcons++)
    9497          64 :                 if (atooid(PQgetvalue(res, j + numcons, i_conrelid)) != conrelid)
    9498          64 :                     break;
    9499             : 
    9500             :             /*
    9501             :              * Locate the associated TableInfo; we rely on tblinfo[] being in
    9502             :              * OID order.
    9503             :              */
    9504       31690 :             while (++curtblindx < numTables)
    9505             :             {
    9506       31690 :                 tbinfo = &tblinfo[curtblindx];
    9507       31690 :                 if (tbinfo->dobj.catId.oid == conrelid)
    9508         152 :                     break;
    9509             :             }
    9510         152 :             if (curtblindx >= numTables)
    9511           0 :                 pg_fatal("unrecognized table OID %u", conrelid);
    9512             : 
    9513         304 :             for (int c = 0; c < numcons; c++, j++)
    9514             :             {
    9515         152 :                 constrs[j].dobj.objType = DO_CONSTRAINT;
    9516         152 :                 constrs[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
    9517         152 :                 constrs[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
    9518         152 :                 AssignDumpId(&constrs[j].dobj);
    9519         152 :                 constrs[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
    9520         152 :                 constrs[j].dobj.namespace = tbinfo->dobj.namespace;
    9521         152 :                 constrs[j].contable = tbinfo;
    9522         152 :                 constrs[j].condomain = NULL;
    9523         152 :                 constrs[j].contype = 'n';
    9524         152 :                 constrs[j].condef = pg_strdup(PQgetvalue(res, j, i_consrc));
    9525         152 :                 constrs[j].confrelid = InvalidOid;
    9526         152 :                 constrs[j].conindex = 0;
    9527         152 :                 constrs[j].condeferrable = false;
    9528         152 :                 constrs[j].condeferred = false;
    9529         152 :                 constrs[j].conislocal = (PQgetvalue(res, j, i_conislocal)[0] == 't');
    9530             : 
    9531             :                 /*
    9532             :                  * All invalid not-null constraints must be dumped separately,
    9533             :                  * because CREATE TABLE would not create them as invalid, and
    9534             :                  * also because they must be created after potentially
    9535             :                  * violating data has been loaded.
    9536             :                  */
    9537         152 :                 constrs[j].separate = true;
    9538             : 
    9539         152 :                 constrs[j].dobj.dump = tbinfo->dobj.dump;
    9540             :             }
    9541             :         }
    9542          88 :         PQclear(res);
    9543             :     }
    9544             : 
    9545             :     /*
    9546             :      * Get info about table CHECK constraints.  This is skipped for a
    9547             :      * data-only dump, as it is only needed for table schemas.
    9548             :      */
    9549         468 :     if (dopt->dumpSchema && checkoids->len > 2)
    9550             :     {
    9551             :         ConstraintInfo *constrs;
    9552             :         int         numConstrs;
    9553             :         int         i_tableoid;
    9554             :         int         i_oid;
    9555             :         int         i_conrelid;
    9556             :         int         i_conname;
    9557             :         int         i_consrc;
    9558             :         int         i_conislocal;
    9559             :         int         i_convalidated;
    9560             : 
    9561         136 :         pg_log_info("finding table check constraints");
    9562             : 
    9563         136 :         resetPQExpBuffer(q);
    9564         136 :         appendPQExpBuffer(q,
    9565             :                           "SELECT c.tableoid, c.oid, conrelid, conname, "
    9566             :                           "pg_catalog.pg_get_constraintdef(c.oid) AS consrc, "
    9567             :                           "conislocal, convalidated "
    9568             :                           "FROM unnest('%s'::pg_catalog.oid[]) AS src(tbloid)\n"
    9569             :                           "JOIN pg_catalog.pg_constraint c ON (src.tbloid = c.conrelid)\n"
    9570             :                           "WHERE contype = 'c' "
    9571             :                           "ORDER BY c.conrelid, c.conname",
    9572             :                           checkoids->data);
    9573             : 
    9574         136 :         res = ExecuteSqlQuery(fout, q->data, PGRES_TUPLES_OK);
    9575             : 
    9576         136 :         numConstrs = PQntuples(res);
    9577         136 :         constrs = (ConstraintInfo *) pg_malloc(numConstrs * sizeof(ConstraintInfo));
    9578             : 
    9579         136 :         i_tableoid = PQfnumber(res, "tableoid");
    9580         136 :         i_oid = PQfnumber(res, "oid");
    9581         136 :         i_conrelid = PQfnumber(res, "conrelid");
    9582         136 :         i_conname = PQfnumber(res, "conname");
    9583         136 :         i_consrc = PQfnumber(res, "consrc");
    9584         136 :         i_conislocal = PQfnumber(res, "conislocal");
    9585         136 :         i_convalidated = PQfnumber(res, "convalidated");
    9586             : 
    9587             :         /* As above, this loop iterates once per table, not once per row */
    9588         136 :         curtblindx = -1;
    9589        1396 :         for (int j = 0; j < numConstrs;)
    9590             :         {
    9591        1260 :             Oid         conrelid = atooid(PQgetvalue(res, j, i_conrelid));
    9592        1260 :             TableInfo  *tbinfo = NULL;
    9593             :             int         numcons;
    9594             : 
    9595             :             /* Count rows for this table */
    9596        1630 :             for (numcons = 1; numcons < numConstrs - j; numcons++)
    9597        1494 :                 if (atooid(PQgetvalue(res, j + numcons, i_conrelid)) != conrelid)
    9598        1124 :                     break;
    9599             : 
    9600             :             /*
    9601             :              * Locate the associated TableInfo; we rely on tblinfo[] being in
    9602             :              * OID order.
    9603             :              */
    9604       43300 :             while (++curtblindx < numTables)
    9605             :             {
    9606       43300 :                 tbinfo = &tblinfo[curtblindx];
    9607       43300 :                 if (tbinfo->dobj.catId.oid == conrelid)
    9608        1260 :                     break;
    9609             :             }
    9610        1260 :             if (curtblindx >= numTables)
    9611           0 :                 pg_fatal("unrecognized table OID %u", conrelid);
    9612             : 
    9613        1260 :             if (numcons != tbinfo->ncheck)
    9614             :             {
    9615           0 :                 pg_log_error(ngettext("expected %d check constraint on table \"%s\" but found %d",
    9616             :                                       "expected %d check constraints on table \"%s\" but found %d",
    9617             :                                       tbinfo->ncheck),
    9618             :                              tbinfo->ncheck, tbinfo->dobj.name, numcons);
    9619           0 :                 pg_log_error_hint("The system catalogs might be corrupted.");
    9620           0 :                 exit_nicely(1);
    9621             :             }
    9622             : 
    9623        1260 :             tbinfo->checkexprs = constrs + j;
    9624             : 
    9625        2890 :             for (int c = 0; c < numcons; c++, j++)
    9626             :             {
    9627        1630 :                 bool        validated = PQgetvalue(res, j, i_convalidated)[0] == 't';
    9628             : 
    9629        1630 :                 constrs[j].dobj.objType = DO_CONSTRAINT;
    9630        1630 :                 constrs[j].dobj.catId.tableoid = atooid(PQgetvalue(res, j, i_tableoid));
    9631        1630 :                 constrs[j].dobj.catId.oid = atooid(PQgetvalue(res, j, i_oid));
    9632        1630 :                 AssignDumpId(&constrs[j].dobj);
    9633        1630 :                 constrs[j].dobj.name = pg_strdup(PQgetvalue(res, j, i_conname));
    9634        1630 :                 constrs[j].dobj.namespace = tbinfo->dobj.namespace;
    9635        1630 :                 constrs[j].contable = tbinfo;
    9636        1630 :                 constrs[j].condomain = NULL;
    9637        1630 :                 constrs[j].contype = 'c';
    9638        1630 :                 constrs[j].condef = pg_strdup(PQgetvalue(res, j, i_consrc));
    9639        1630 :                 constrs[j].confrelid = InvalidOid;
    9640        1630 :                 constrs[j].conindex = 0;
    9641        1630 :                 constrs[j].condeferrable = false;
    9642        1630 :                 constrs[j].condeferred = false;
    9643        1630 :                 constrs[j].conislocal = (PQgetvalue(res, j, i_conislocal)[0] == 't');
    9644             : 
    9645             :                 /*
    9646             :                  * An unvalidated constraint needs to be dumped separately, so
    9647             :                  * that potentially-violating existing data is loaded before
    9648             :                  * the constraint.
    9649             :                  */
    9650        1630 :                 constrs[j].separate = !validated;
    9651             : 
    9652        1630 :                 constrs[j].dobj.dump = tbinfo->dobj.dump;
    9653             : 
    9654             :                 /*
    9655             :                  * Mark the constraint as needing to appear before the table
    9656             :                  * --- this is so that any other dependencies of the
    9657             :                  * constraint will be emitted before we try to create the
    9658             :                  * table.  If the constraint is to be dumped separately, it
    9659             :                  * will be dumped after data is loaded anyway, so don't do it.
    9660             :                  * (There's an automatic dependency in the opposite direction
    9661             :                  * anyway, so don't need to add one manually here.)
    9662             :                  */
    9663        1630 :                 if (!constrs[j].separate)
    9664        1422 :                     addObjectDependency(&tbinfo->dobj,
    9665        1422 :                                         constrs[j].dobj.dumpId);
    9666             : 
    9667             :                 /*
    9668             :                  * We will detect later whether the constraint must be split
    9669             :                  * out from the table definition.
    9670             :                  */
    9671             :             }
    9672             :         }
    9673             : 
    9674         136 :         PQclear(res);
    9675             :     }
    9676             : 
    9677         468 :     destroyPQExpBuffer(q);
    9678         468 :     destroyPQExpBuffer(tbloids);
    9679         468 :     destroyPQExpBuffer(checkoids);
    9680         468 : }
    9681             : 
    9682             : /*
    9683             :  * Based on the getTableAttrs query's row corresponding to one column, set
    9684             :  * the name and flags to handle a not-null constraint for that column in
    9685             :  * the tbinfo struct.
    9686             :  *
    9687             :  * Result row 'r' is for tbinfo's attribute 'j'.
    9688             :  *
    9689             :  * There are four possibilities:
    9690             :  * 1) the column has no not-null constraints. In that case, ->notnull_constrs
    9691             :  *    (the constraint name) remains NULL.
    9692             :  * 2) The column has a constraint with no name (this is the case when
    9693             :  *    constraints come from pre-18 servers).  In this case, ->notnull_constrs
    9694             :  *    is set to the empty string; dumpTableSchema will print just "NOT NULL".
    9695             :  * 3) The column has an invalid not-null constraint.  This must be treated
    9696             :  *    as a separate object (because it must be created after the table data
    9697             :  *    is loaded).  So we add its OID to invalidnotnulloids for processing
    9698             :  *    elsewhere and do nothing further with it here.  We distinguish this
    9699             :  *    case because the "notnull_invalidoid" column has been set to a non-NULL
    9700             :  *    value, which is the constraint OID.  Valid constraints have a null OID.
    9701             :  * 4) The column has a constraint with a known name; in that case
    9702             :  *    notnull_constrs carries that name and dumpTableSchema will print
    9703             :  *    "CONSTRAINT the_name NOT NULL".  However, if the name is the default
    9704             :  *    (table_column_not_null), there's no need to print that name in the dump,
    9705             :  *    so notnull_constrs is set to the empty string and it behaves as case 2.
    9706             :  *
    9707             :  * In a child table that inherits from a parent already containing NOT NULL
    9708             :  * constraints and the columns in the child don't have their own NOT NULL
    9709             :  * declarations, we suppress printing constraints in the child: the
    9710             :  * constraints are acquired at the point where the child is attached to the
    9711             :  * parent.  This is tracked in ->notnull_islocal (which is set in flagInhAttrs
    9712             :  * for servers pre-18).
    9713             :  *
    9714             :  * Any of these constraints might have the NO INHERIT bit.  If so we set
    9715             :  * ->notnull_noinh and NO INHERIT will be printed by dumpTableSchema.
    9716             :  *
    9717             :  * In case 4 above, the name comparison is a bit of a hack; it actually fails
    9718             :  * to do the right thing in all but the trivial case.  However, the downside
    9719             :  * of getting it wrong is simply that the name is printed rather than
    9720             :  * suppressed, so it's not a big deal.
    9721             :  *
    9722             :  * invalidnotnulloids is expected to be given as NULL; if any invalid not-null
    9723             :  * constraints are found, it is initialized and filled with the array of
    9724             :  * OIDs of such constraints, for later processing.
    9725             :  */
    9726             : static void
    9727       67580 : determineNotNullFlags(Archive *fout, PGresult *res, int r,
    9728             :                       TableInfo *tbinfo, int j,
    9729             :                       int i_notnull_name,
    9730             :                       int i_notnull_invalidoid,
    9731             :                       int i_notnull_noinherit,
    9732             :                       int i_notnull_islocal,
    9733             :                       PQExpBuffer *invalidnotnulloids)
    9734             : {
    9735       67580 :     DumpOptions *dopt = fout->dopt;
    9736             : 
    9737             :     /*
    9738             :      * If this not-null constraint is not valid, list its OID in
    9739             :      * invalidnotnulloids and do nothing further.  It'll be processed
    9740             :      * elsewhere later.
    9741             :      *
    9742             :      * Because invalid not-null constraints are rare, we don't want to malloc
    9743             :      * invalidnotnulloids until we're sure we're going it need it, which
    9744             :      * happens here.
    9745             :      */
    9746       67580 :     if (!PQgetisnull(res, r, i_notnull_invalidoid))
    9747             :     {
    9748         164 :         char       *constroid = PQgetvalue(res, r, i_notnull_invalidoid);
    9749             : 
    9750         164 :         if (*invalidnotnulloids == NULL)
    9751             :         {
    9752         100 :             *invalidnotnulloids = createPQExpBuffer();
    9753         100 :             appendPQExpBufferChar(*invalidnotnulloids, '{');
    9754         100 :             appendPQExpBufferStr(*invalidnotnulloids, constroid);
    9755             :         }
    9756             :         else
    9757          64 :             appendPQExpBuffer(*invalidnotnulloids, ",%s", constroid);
    9758             : 
    9759             :         /* nothing else to do */
    9760         164 :         tbinfo->notnull_constrs[j] = NULL;
    9761         164 :         return;
    9762             :     }
    9763             : 
    9764             :     /*
    9765             :      * notnull_noinh is straight from the query result. notnull_islocal also,
    9766             :      * though flagInhAttrs may change that one later in versions < 18.
    9767             :      */
    9768       67416 :     tbinfo->notnull_noinh[j] = PQgetvalue(res, r, i_notnull_noinherit)[0] == 't';
    9769       67416 :     tbinfo->notnull_islocal[j] = PQgetvalue(res, r, i_notnull_islocal)[0] == 't';
    9770             : 
    9771             :     /*
    9772             :      * Determine a constraint name to use.  If the column is not marked not-
    9773             :      * null, we set NULL which cues ... to do nothing.  An empty string says
    9774             :      * to print an unnamed NOT NULL, and anything else is a constraint name to
    9775             :      * use.
    9776             :      */
    9777       67416 :     if (fout->remoteVersion < 180000)
    9778             :     {
    9779             :         /*
    9780             :          * < 18 doesn't have not-null names, so an unnamed constraint is
    9781             :          * sufficient.
    9782             :          */
    9783           0 :         if (PQgetisnull(res, r, i_notnull_name))
    9784           0 :             tbinfo->notnull_constrs[j] = NULL;
    9785             :         else
    9786           0 :             tbinfo->notnull_constrs[j] = "";
    9787             :     }
    9788             :     else
    9789             :     {
    9790       67416 :         if (PQgetisnull(res, r, i_notnull_name))
    9791       60944 :             tbinfo->notnull_constrs[j] = NULL;
    9792             :         else
    9793             :         {
    9794             :             /*
    9795             :              * In binary upgrade of inheritance child tables, must have a
    9796             :              * constraint name that we can UPDATE later.
    9797             :              */
    9798        6472 :             if (dopt->binary_upgrade &&
    9799         560 :                 !tbinfo->ispartition &&
    9800         404 :                 !tbinfo->notnull_islocal)
    9801             :             {
    9802           0 :                 tbinfo->notnull_constrs[j] =
    9803           0 :                     pstrdup(PQgetvalue(res, r, i_notnull_name));
    9804             :             }
    9805             :             else
    9806             :             {
    9807             :                 char       *default_name;
    9808             : 
    9809             :                 /* XXX should match ChooseConstraintName better */
    9810        6472 :                 default_name = psprintf("%s_%s_not_null", tbinfo->dobj.name,
    9811        6472 :                                         tbinfo->attnames[j]);
    9812        6472 :                 if (strcmp(default_name,
    9813        6472 :                            PQgetvalue(res, r, i_notnull_name)) == 0)
    9814        4352 :                     tbinfo->notnull_constrs[j] = "";
    9815             :                 else
    9816             :                 {
    9817        2120 :                     tbinfo->notnull_constrs[j] =
    9818        2120 :                         pstrdup(PQgetvalue(res, r, i_notnull_name));
    9819             :                 }
    9820        6472 :                 free(default_name);
    9821             :             }
    9822             :         }
    9823             :     }
    9824             : }
    9825             : 
    9826             : /*
    9827             :  * Test whether a column should be printed as part of table's CREATE TABLE.
    9828             :  * Column number is zero-based.
    9829             :  *
    9830             :  * Normally this is always true, but it's false for dropped columns, as well
    9831             :  * as those that were inherited without any local definition.  (If we print
    9832             :  * such a column it will mistakenly get pg_attribute.attislocal set to true.)
    9833             :  * For partitions, it's always true, because we want the partitions to be
    9834             :  * created independently and ATTACH PARTITION used afterwards.
    9835             :  *
    9836             :  * In binary_upgrade mode, we must print all columns and fix the attislocal/
    9837             :  * attisdropped state later, so as to keep control of the physical column
    9838             :  * order.
    9839             :  *
    9840             :  * This function exists because there are scattered nonobvious places that
    9841             :  * must be kept in sync with this decision.
    9842             :  */
    9843             : bool
    9844      116400 : shouldPrintColumn(const DumpOptions *dopt, const TableInfo *tbinfo, int colno)
    9845             : {
    9846      116400 :     if (dopt->binary_upgrade)
    9847       12268 :         return true;
    9848      104132 :     if (tbinfo->attisdropped[colno])
    9849        2132 :         return false;
    9850      102000 :     return (tbinfo->attislocal[colno] || tbinfo->ispartition);
    9851             : }
    9852             : 
    9853             : 
    9854             : /*
    9855             :  * getTSParsers:
    9856             :  *    get information about all text search parsers in the system catalogs
    9857             :  */
    9858             : void
    9859         468 : getTSParsers(Archive *fout)
    9860             : {
    9861             :     PGresult   *res;
    9862             :     int         ntups;
    9863             :     int         i;
    9864             :     PQExpBuffer query;
    9865             :     TSParserInfo *prsinfo;
    9866             :     int         i_tableoid;
    9867             :     int         i_oid;
    9868             :     int         i_prsname;
    9869             :     int         i_prsnamespace;
    9870             :     int         i_prsstart;
    9871             :     int         i_prstoken;
    9872             :     int         i_prsend;
    9873             :     int         i_prsheadline;
    9874             :     int         i_prslextype;
    9875             : 
    9876         468 :     query = createPQExpBuffer();
    9877             : 
    9878             :     /*
    9879             :      * find all text search objects, including builtin ones; we filter out
    9880             :      * system-defined objects at dump-out time.
    9881             :      */
    9882             : 
    9883         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, prsname, prsnamespace, "
    9884             :                          "prsstart::oid, prstoken::oid, "
    9885             :                          "prsend::oid, prsheadline::oid, prslextype::oid "
    9886             :                          "FROM pg_ts_parser");
    9887             : 
    9888         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    9889             : 
    9890         468 :     ntups = PQntuples(res);
    9891             : 
    9892         468 :     prsinfo = (TSParserInfo *) pg_malloc(ntups * sizeof(TSParserInfo));
    9893             : 
    9894         468 :     i_tableoid = PQfnumber(res, "tableoid");
    9895         468 :     i_oid = PQfnumber(res, "oid");
    9896         468 :     i_prsname = PQfnumber(res, "prsname");
    9897         468 :     i_prsnamespace = PQfnumber(res, "prsnamespace");
    9898         468 :     i_prsstart = PQfnumber(res, "prsstart");
    9899         468 :     i_prstoken = PQfnumber(res, "prstoken");
    9900         468 :     i_prsend = PQfnumber(res, "prsend");
    9901         468 :     i_prsheadline = PQfnumber(res, "prsheadline");
    9902         468 :     i_prslextype = PQfnumber(res, "prslextype");
    9903             : 
    9904        1034 :     for (i = 0; i < ntups; i++)
    9905             :     {
    9906         566 :         prsinfo[i].dobj.objType = DO_TSPARSER;
    9907         566 :         prsinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    9908         566 :         prsinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    9909         566 :         AssignDumpId(&prsinfo[i].dobj);
    9910         566 :         prsinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_prsname));
    9911        1132 :         prsinfo[i].dobj.namespace =
    9912         566 :             findNamespace(atooid(PQgetvalue(res, i, i_prsnamespace)));
    9913         566 :         prsinfo[i].prsstart = atooid(PQgetvalue(res, i, i_prsstart));
    9914         566 :         prsinfo[i].prstoken = atooid(PQgetvalue(res, i, i_prstoken));
    9915         566 :         prsinfo[i].prsend = atooid(PQgetvalue(res, i, i_prsend));
    9916         566 :         prsinfo[i].prsheadline = atooid(PQgetvalue(res, i, i_prsheadline));
    9917         566 :         prsinfo[i].prslextype = atooid(PQgetvalue(res, i, i_prslextype));
    9918             : 
    9919             :         /* Decide whether we want to dump it */
    9920         566 :         selectDumpableObject(&(prsinfo[i].dobj), fout);
    9921             :     }
    9922             : 
    9923         468 :     PQclear(res);
    9924             : 
    9925         468 :     destroyPQExpBuffer(query);
    9926         468 : }
    9927             : 
    9928             : /*
    9929             :  * getTSDictionaries:
    9930             :  *    get information about all text search dictionaries in the system catalogs
    9931             :  */
    9932             : void
    9933         468 : getTSDictionaries(Archive *fout)
    9934             : {
    9935             :     PGresult   *res;
    9936             :     int         ntups;
    9937             :     int         i;
    9938             :     PQExpBuffer query;
    9939             :     TSDictInfo *dictinfo;
    9940             :     int         i_tableoid;
    9941             :     int         i_oid;
    9942             :     int         i_dictname;
    9943             :     int         i_dictnamespace;
    9944             :     int         i_dictowner;
    9945             :     int         i_dicttemplate;
    9946             :     int         i_dictinitoption;
    9947             : 
    9948         468 :     query = createPQExpBuffer();
    9949             : 
    9950         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, dictname, "
    9951             :                          "dictnamespace, dictowner, "
    9952             :                          "dicttemplate, dictinitoption "
    9953             :                          "FROM pg_ts_dict");
    9954             : 
    9955         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
    9956             : 
    9957         468 :     ntups = PQntuples(res);
    9958             : 
    9959         468 :     dictinfo = (TSDictInfo *) pg_malloc(ntups * sizeof(TSDictInfo));
    9960             : 
    9961         468 :     i_tableoid = PQfnumber(res, "tableoid");
    9962         468 :     i_oid = PQfnumber(res, "oid");
    9963         468 :     i_dictname = PQfnumber(res, "dictname");
    9964         468 :     i_dictnamespace = PQfnumber(res, "dictnamespace");
    9965         468 :     i_dictowner = PQfnumber(res, "dictowner");
    9966         468 :     i_dictinitoption = PQfnumber(res, "dictinitoption");
    9967         468 :     i_dicttemplate = PQfnumber(res, "dicttemplate");
    9968             : 
    9969       14786 :     for (i = 0; i < ntups; i++)
    9970             :     {
    9971       14318 :         dictinfo[i].dobj.objType = DO_TSDICT;
    9972       14318 :         dictinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
    9973       14318 :         dictinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
    9974       14318 :         AssignDumpId(&dictinfo[i].dobj);
    9975       14318 :         dictinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_dictname));
    9976       28636 :         dictinfo[i].dobj.namespace =
    9977       14318 :             findNamespace(atooid(PQgetvalue(res, i, i_dictnamespace)));
    9978       14318 :         dictinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_dictowner));
    9979       14318 :         dictinfo[i].dicttemplate = atooid(PQgetvalue(res, i, i_dicttemplate));
    9980       14318 :         if (PQgetisnull(res, i, i_dictinitoption))
    9981         566 :             dictinfo[i].dictinitoption = NULL;
    9982             :         else
    9983       13752 :             dictinfo[i].dictinitoption = pg_strdup(PQgetvalue(res, i, i_dictinitoption));
    9984             : 
    9985             :         /* Decide whether we want to dump it */
    9986       14318 :         selectDumpableObject(&(dictinfo[i].dobj), fout);
    9987             :     }
    9988             : 
    9989         468 :     PQclear(res);
    9990             : 
    9991         468 :     destroyPQExpBuffer(query);
    9992         468 : }
    9993             : 
    9994             : /*
    9995             :  * getTSTemplates:
    9996             :  *    get information about all text search templates in the system catalogs
    9997             :  */
    9998             : void
    9999         468 : getTSTemplates(Archive *fout)
   10000             : {
   10001             :     PGresult   *res;
   10002             :     int         ntups;
   10003             :     int         i;
   10004             :     PQExpBuffer query;
   10005             :     TSTemplateInfo *tmplinfo;
   10006             :     int         i_tableoid;
   10007             :     int         i_oid;
   10008             :     int         i_tmplname;
   10009             :     int         i_tmplnamespace;
   10010             :     int         i_tmplinit;
   10011             :     int         i_tmpllexize;
   10012             : 
   10013         468 :     query = createPQExpBuffer();
   10014             : 
   10015         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, tmplname, "
   10016             :                          "tmplnamespace, tmplinit::oid, tmpllexize::oid "
   10017             :                          "FROM pg_ts_template");
   10018             : 
   10019         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10020             : 
   10021         468 :     ntups = PQntuples(res);
   10022             : 
   10023         468 :     tmplinfo = (TSTemplateInfo *) pg_malloc(ntups * sizeof(TSTemplateInfo));
   10024             : 
   10025         468 :     i_tableoid = PQfnumber(res, "tableoid");
   10026         468 :     i_oid = PQfnumber(res, "oid");
   10027         468 :     i_tmplname = PQfnumber(res, "tmplname");
   10028         468 :     i_tmplnamespace = PQfnumber(res, "tmplnamespace");
   10029         468 :     i_tmplinit = PQfnumber(res, "tmplinit");
   10030         468 :     i_tmpllexize = PQfnumber(res, "tmpllexize");
   10031             : 
   10032        2906 :     for (i = 0; i < ntups; i++)
   10033             :     {
   10034        2438 :         tmplinfo[i].dobj.objType = DO_TSTEMPLATE;
   10035        2438 :         tmplinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
   10036        2438 :         tmplinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
   10037        2438 :         AssignDumpId(&tmplinfo[i].dobj);
   10038        2438 :         tmplinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_tmplname));
   10039        4876 :         tmplinfo[i].dobj.namespace =
   10040        2438 :             findNamespace(atooid(PQgetvalue(res, i, i_tmplnamespace)));
   10041        2438 :         tmplinfo[i].tmplinit = atooid(PQgetvalue(res, i, i_tmplinit));
   10042        2438 :         tmplinfo[i].tmpllexize = atooid(PQgetvalue(res, i, i_tmpllexize));
   10043             : 
   10044             :         /* Decide whether we want to dump it */
   10045        2438 :         selectDumpableObject(&(tmplinfo[i].dobj), fout);
   10046             :     }
   10047             : 
   10048         468 :     PQclear(res);
   10049             : 
   10050         468 :     destroyPQExpBuffer(query);
   10051         468 : }
   10052             : 
   10053             : /*
   10054             :  * getTSConfigurations:
   10055             :  *    get information about all text search configurations
   10056             :  */
   10057             : void
   10058         468 : getTSConfigurations(Archive *fout)
   10059             : {
   10060             :     PGresult   *res;
   10061             :     int         ntups;
   10062             :     int         i;
   10063             :     PQExpBuffer query;
   10064             :     TSConfigInfo *cfginfo;
   10065             :     int         i_tableoid;
   10066             :     int         i_oid;
   10067             :     int         i_cfgname;
   10068             :     int         i_cfgnamespace;
   10069             :     int         i_cfgowner;
   10070             :     int         i_cfgparser;
   10071             : 
   10072         468 :     query = createPQExpBuffer();
   10073             : 
   10074         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, cfgname, "
   10075             :                          "cfgnamespace, cfgowner, cfgparser "
   10076             :                          "FROM pg_ts_config");
   10077             : 
   10078         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10079             : 
   10080         468 :     ntups = PQntuples(res);
   10081             : 
   10082         468 :     cfginfo = (TSConfigInfo *) pg_malloc(ntups * sizeof(TSConfigInfo));
   10083             : 
   10084         468 :     i_tableoid = PQfnumber(res, "tableoid");
   10085         468 :     i_oid = PQfnumber(res, "oid");
   10086         468 :     i_cfgname = PQfnumber(res, "cfgname");
   10087         468 :     i_cfgnamespace = PQfnumber(res, "cfgnamespace");
   10088         468 :     i_cfgowner = PQfnumber(res, "cfgowner");
   10089         468 :     i_cfgparser = PQfnumber(res, "cfgparser");
   10090             : 
   10091       14686 :     for (i = 0; i < ntups; i++)
   10092             :     {
   10093       14218 :         cfginfo[i].dobj.objType = DO_TSCONFIG;
   10094       14218 :         cfginfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
   10095       14218 :         cfginfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
   10096       14218 :         AssignDumpId(&cfginfo[i].dobj);
   10097       14218 :         cfginfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_cfgname));
   10098       28436 :         cfginfo[i].dobj.namespace =
   10099       14218 :             findNamespace(atooid(PQgetvalue(res, i, i_cfgnamespace)));
   10100       14218 :         cfginfo[i].rolname = getRoleName(PQgetvalue(res, i, i_cfgowner));
   10101       14218 :         cfginfo[i].cfgparser = atooid(PQgetvalue(res, i, i_cfgparser));
   10102             : 
   10103             :         /* Decide whether we want to dump it */
   10104       14218 :         selectDumpableObject(&(cfginfo[i].dobj), fout);
   10105             :     }
   10106             : 
   10107         468 :     PQclear(res);
   10108             : 
   10109         468 :     destroyPQExpBuffer(query);
   10110         468 : }
   10111             : 
   10112             : /*
   10113             :  * getForeignDataWrappers:
   10114             :  *    get information about all foreign-data wrappers in the system catalogs
   10115             :  */
   10116             : void
   10117         468 : getForeignDataWrappers(Archive *fout)
   10118             : {
   10119             :     PGresult   *res;
   10120             :     int         ntups;
   10121             :     int         i;
   10122             :     PQExpBuffer query;
   10123             :     FdwInfo    *fdwinfo;
   10124             :     int         i_tableoid;
   10125             :     int         i_oid;
   10126             :     int         i_fdwname;
   10127             :     int         i_fdwowner;
   10128             :     int         i_fdwhandler;
   10129             :     int         i_fdwvalidator;
   10130             :     int         i_fdwacl;
   10131             :     int         i_acldefault;
   10132             :     int         i_fdwoptions;
   10133             : 
   10134         468 :     query = createPQExpBuffer();
   10135             : 
   10136         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, fdwname, "
   10137             :                          "fdwowner, "
   10138             :                          "fdwhandler::pg_catalog.regproc, "
   10139             :                          "fdwvalidator::pg_catalog.regproc, "
   10140             :                          "fdwacl, "
   10141             :                          "acldefault('F', fdwowner) AS acldefault, "
   10142             :                          "array_to_string(ARRAY("
   10143             :                          "SELECT quote_ident(option_name) || ' ' || "
   10144             :                          "quote_literal(option_value) "
   10145             :                          "FROM pg_options_to_table(fdwoptions) "
   10146             :                          "ORDER BY option_name"
   10147             :                          "), E',\n    ') AS fdwoptions "
   10148             :                          "FROM pg_foreign_data_wrapper");
   10149             : 
   10150         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10151             : 
   10152         468 :     ntups = PQntuples(res);
   10153             : 
   10154         468 :     fdwinfo = (FdwInfo *) pg_malloc(ntups * sizeof(FdwInfo));
   10155             : 
   10156         468 :     i_tableoid = PQfnumber(res, "tableoid");
   10157         468 :     i_oid = PQfnumber(res, "oid");
   10158         468 :     i_fdwname = PQfnumber(res, "fdwname");
   10159         468 :     i_fdwowner = PQfnumber(res, "fdwowner");
   10160         468 :     i_fdwhandler = PQfnumber(res, "fdwhandler");
   10161         468 :     i_fdwvalidator = PQfnumber(res, "fdwvalidator");
   10162         468 :     i_fdwacl = PQfnumber(res, "fdwacl");
   10163         468 :     i_acldefault = PQfnumber(res, "acldefault");
   10164         468 :     i_fdwoptions = PQfnumber(res, "fdwoptions");
   10165             : 
   10166         624 :     for (i = 0; i < ntups; i++)
   10167             :     {
   10168         156 :         fdwinfo[i].dobj.objType = DO_FDW;
   10169         156 :         fdwinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
   10170         156 :         fdwinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
   10171         156 :         AssignDumpId(&fdwinfo[i].dobj);
   10172         156 :         fdwinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_fdwname));
   10173         156 :         fdwinfo[i].dobj.namespace = NULL;
   10174         156 :         fdwinfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_fdwacl));
   10175         156 :         fdwinfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
   10176         156 :         fdwinfo[i].dacl.privtype = 0;
   10177         156 :         fdwinfo[i].dacl.initprivs = NULL;
   10178         156 :         fdwinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_fdwowner));
   10179         156 :         fdwinfo[i].fdwhandler = pg_strdup(PQgetvalue(res, i, i_fdwhandler));
   10180         156 :         fdwinfo[i].fdwvalidator = pg_strdup(PQgetvalue(res, i, i_fdwvalidator));
   10181         156 :         fdwinfo[i].fdwoptions = pg_strdup(PQgetvalue(res, i, i_fdwoptions));
   10182             : 
   10183             :         /* Decide whether we want to dump it */
   10184         156 :         selectDumpableObject(&(fdwinfo[i].dobj), fout);
   10185             : 
   10186             :         /* Mark whether FDW has an ACL */
   10187         156 :         if (!PQgetisnull(res, i, i_fdwacl))
   10188          98 :             fdwinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
   10189             :     }
   10190             : 
   10191         468 :     PQclear(res);
   10192             : 
   10193         468 :     destroyPQExpBuffer(query);
   10194         468 : }
   10195             : 
   10196             : /*
   10197             :  * getForeignServers:
   10198             :  *    get information about all foreign servers in the system catalogs
   10199             :  */
   10200             : void
   10201         468 : getForeignServers(Archive *fout)
   10202             : {
   10203             :     PGresult   *res;
   10204             :     int         ntups;
   10205             :     int         i;
   10206             :     PQExpBuffer query;
   10207             :     ForeignServerInfo *srvinfo;
   10208             :     int         i_tableoid;
   10209             :     int         i_oid;
   10210             :     int         i_srvname;
   10211             :     int         i_srvowner;
   10212             :     int         i_srvfdw;
   10213             :     int         i_srvtype;
   10214             :     int         i_srvversion;
   10215             :     int         i_srvacl;
   10216             :     int         i_acldefault;
   10217             :     int         i_srvoptions;
   10218             : 
   10219         468 :     query = createPQExpBuffer();
   10220             : 
   10221         468 :     appendPQExpBufferStr(query, "SELECT tableoid, oid, srvname, "
   10222             :                          "srvowner, "
   10223             :                          "srvfdw, srvtype, srvversion, srvacl, "
   10224             :                          "acldefault('S', srvowner) AS acldefault, "
   10225             :                          "array_to_string(ARRAY("
   10226             :                          "SELECT quote_ident(option_name) || ' ' || "
   10227             :                          "quote_literal(option_value) "
   10228             :                          "FROM pg_options_to_table(srvoptions) "
   10229             :                          "ORDER BY option_name"
   10230             :                          "), E',\n    ') AS srvoptions "
   10231             :                          "FROM pg_foreign_server");
   10232             : 
   10233         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10234             : 
   10235         468 :     ntups = PQntuples(res);
   10236             : 
   10237         468 :     srvinfo = (ForeignServerInfo *) pg_malloc(ntups * sizeof(ForeignServerInfo));
   10238             : 
   10239         468 :     i_tableoid = PQfnumber(res, "tableoid");
   10240         468 :     i_oid = PQfnumber(res, "oid");
   10241         468 :     i_srvname = PQfnumber(res, "srvname");
   10242         468 :     i_srvowner = PQfnumber(res, "srvowner");
   10243         468 :     i_srvfdw = PQfnumber(res, "srvfdw");
   10244         468 :     i_srvtype = PQfnumber(res, "srvtype");
   10245         468 :     i_srvversion = PQfnumber(res, "srvversion");
   10246         468 :     i_srvacl = PQfnumber(res, "srvacl");
   10247         468 :     i_acldefault = PQfnumber(res, "acldefault");
   10248         468 :     i_srvoptions = PQfnumber(res, "srvoptions");
   10249             : 
   10250         632 :     for (i = 0; i < ntups; i++)
   10251             :     {
   10252         164 :         srvinfo[i].dobj.objType = DO_FOREIGN_SERVER;
   10253         164 :         srvinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
   10254         164 :         srvinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
   10255         164 :         AssignDumpId(&srvinfo[i].dobj);
   10256         164 :         srvinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_srvname));
   10257         164 :         srvinfo[i].dobj.namespace = NULL;
   10258         164 :         srvinfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_srvacl));
   10259         164 :         srvinfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
   10260         164 :         srvinfo[i].dacl.privtype = 0;
   10261         164 :         srvinfo[i].dacl.initprivs = NULL;
   10262         164 :         srvinfo[i].rolname = getRoleName(PQgetvalue(res, i, i_srvowner));
   10263         164 :         srvinfo[i].srvfdw = atooid(PQgetvalue(res, i, i_srvfdw));
   10264         164 :         srvinfo[i].srvtype = pg_strdup(PQgetvalue(res, i, i_srvtype));
   10265         164 :         srvinfo[i].srvversion = pg_strdup(PQgetvalue(res, i, i_srvversion));
   10266         164 :         srvinfo[i].srvoptions = pg_strdup(PQgetvalue(res, i, i_srvoptions));
   10267             : 
   10268             :         /* Decide whether we want to dump it */
   10269         164 :         selectDumpableObject(&(srvinfo[i].dobj), fout);
   10270             : 
   10271             :         /* Servers have user mappings */
   10272         164 :         srvinfo[i].dobj.components |= DUMP_COMPONENT_USERMAP;
   10273             : 
   10274             :         /* Mark whether server has an ACL */
   10275         164 :         if (!PQgetisnull(res, i, i_srvacl))
   10276          98 :             srvinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
   10277             :     }
   10278             : 
   10279         468 :     PQclear(res);
   10280             : 
   10281         468 :     destroyPQExpBuffer(query);
   10282         468 : }
   10283             : 
   10284             : /*
   10285             :  * getDefaultACLs:
   10286             :  *    get information about all default ACL information in the system catalogs
   10287             :  */
   10288             : void
   10289         468 : getDefaultACLs(Archive *fout)
   10290             : {
   10291         468 :     DumpOptions *dopt = fout->dopt;
   10292             :     DefaultACLInfo *daclinfo;
   10293             :     PQExpBuffer query;
   10294             :     PGresult   *res;
   10295             :     int         i_oid;
   10296             :     int         i_tableoid;
   10297             :     int         i_defaclrole;
   10298             :     int         i_defaclnamespace;
   10299             :     int         i_defaclobjtype;
   10300             :     int         i_defaclacl;
   10301             :     int         i_acldefault;
   10302             :     int         i,
   10303             :                 ntups;
   10304             : 
   10305         468 :     query = createPQExpBuffer();
   10306             : 
   10307             :     /*
   10308             :      * Global entries (with defaclnamespace=0) replace the hard-wired default
   10309             :      * ACL for their object type.  We should dump them as deltas from the
   10310             :      * default ACL, since that will be used as a starting point for
   10311             :      * interpreting the ALTER DEFAULT PRIVILEGES commands.  On the other hand,
   10312             :      * non-global entries can only add privileges not revoke them.  We must
   10313             :      * dump those as-is (i.e., as deltas from an empty ACL).
   10314             :      *
   10315             :      * We can use defaclobjtype as the object type for acldefault(), except
   10316             :      * for the case of 'S' (DEFACLOBJ_SEQUENCE) which must be converted to
   10317             :      * 's'.
   10318             :      */
   10319         468 :     appendPQExpBufferStr(query,
   10320             :                          "SELECT oid, tableoid, "
   10321             :                          "defaclrole, "
   10322             :                          "defaclnamespace, "
   10323             :                          "defaclobjtype, "
   10324             :                          "defaclacl, "
   10325             :                          "CASE WHEN defaclnamespace = 0 THEN "
   10326             :                          "acldefault(CASE WHEN defaclobjtype = 'S' "
   10327             :                          "THEN 's'::\"char\" ELSE defaclobjtype END, "
   10328             :                          "defaclrole) ELSE '{}' END AS acldefault "
   10329             :                          "FROM pg_default_acl");
   10330             : 
   10331         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10332             : 
   10333         468 :     ntups = PQntuples(res);
   10334             : 
   10335         468 :     daclinfo = (DefaultACLInfo *) pg_malloc(ntups * sizeof(DefaultACLInfo));
   10336             : 
   10337         468 :     i_oid = PQfnumber(res, "oid");
   10338         468 :     i_tableoid = PQfnumber(res, "tableoid");
   10339         468 :     i_defaclrole = PQfnumber(res, "defaclrole");
   10340         468 :     i_defaclnamespace = PQfnumber(res, "defaclnamespace");
   10341         468 :     i_defaclobjtype = PQfnumber(res, "defaclobjtype");
   10342         468 :     i_defaclacl = PQfnumber(res, "defaclacl");
   10343         468 :     i_acldefault = PQfnumber(res, "acldefault");
   10344             : 
   10345         860 :     for (i = 0; i < ntups; i++)
   10346             :     {
   10347         392 :         Oid         nspid = atooid(PQgetvalue(res, i, i_defaclnamespace));
   10348             : 
   10349         392 :         daclinfo[i].dobj.objType = DO_DEFAULT_ACL;
   10350         392 :         daclinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
   10351         392 :         daclinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
   10352         392 :         AssignDumpId(&daclinfo[i].dobj);
   10353             :         /* cheesy ... is it worth coming up with a better object name? */
   10354         392 :         daclinfo[i].dobj.name = pg_strdup(PQgetvalue(res, i, i_defaclobjtype));
   10355             : 
   10356         392 :         if (nspid != InvalidOid)
   10357         196 :             daclinfo[i].dobj.namespace = findNamespace(nspid);
   10358             :         else
   10359         196 :             daclinfo[i].dobj.namespace = NULL;
   10360             : 
   10361         392 :         daclinfo[i].dacl.acl = pg_strdup(PQgetvalue(res, i, i_defaclacl));
   10362         392 :         daclinfo[i].dacl.acldefault = pg_strdup(PQgetvalue(res, i, i_acldefault));
   10363         392 :         daclinfo[i].dacl.privtype = 0;
   10364         392 :         daclinfo[i].dacl.initprivs = NULL;
   10365         392 :         daclinfo[i].defaclrole = getRoleName(PQgetvalue(res, i, i_defaclrole));
   10366         392 :         daclinfo[i].defaclobjtype = *(PQgetvalue(res, i, i_defaclobjtype));
   10367             : 
   10368             :         /* Default ACLs are ACLs, of course */
   10369         392 :         daclinfo[i].dobj.components |= DUMP_COMPONENT_ACL;
   10370             : 
   10371             :         /* Decide whether we want to dump it */
   10372         392 :         selectDumpableDefaultACL(&(daclinfo[i]), dopt);
   10373             :     }
   10374             : 
   10375         468 :     PQclear(res);
   10376             : 
   10377         468 :     destroyPQExpBuffer(query);
   10378         468 : }
   10379             : 
   10380             : /*
   10381             :  * getRoleName -- look up the name of a role, given its OID
   10382             :  *
   10383             :  * In current usage, we don't expect failures, so error out for a bad OID.
   10384             :  */
   10385             : static const char *
   10386     1466106 : getRoleName(const char *roleoid_str)
   10387             : {
   10388     1466106 :     Oid         roleoid = atooid(roleoid_str);
   10389             : 
   10390             :     /*
   10391             :      * Do binary search to find the appropriate item.
   10392             :      */
   10393     1466106 :     if (nrolenames > 0)
   10394             :     {
   10395     1466106 :         RoleNameItem *low = &rolenames[0];
   10396     1466106 :         RoleNameItem *high = &rolenames[nrolenames - 1];
   10397             : 
   10398     5864958 :         while (low <= high)
   10399             :         {
   10400     5864958 :             RoleNameItem *middle = low + (high - low) / 2;
   10401             : 
   10402     5864958 :             if (roleoid < middle->roleoid)
   10403     4395820 :                 high = middle - 1;
   10404     1469138 :             else if (roleoid > middle->roleoid)
   10405        3032 :                 low = middle + 1;
   10406             :             else
   10407     1466106 :                 return middle->rolename; /* found a match */
   10408             :         }
   10409             :     }
   10410             : 
   10411           0 :     pg_fatal("role with OID %u does not exist", roleoid);
   10412             :     return NULL;                /* keep compiler quiet */
   10413             : }
   10414             : 
   10415             : /*
   10416             :  * collectRoleNames --
   10417             :  *
   10418             :  * Construct a table of all known roles.
   10419             :  * The table is sorted by OID for speed in lookup.
   10420             :  */
   10421             : static void
   10422         470 : collectRoleNames(Archive *fout)
   10423             : {
   10424             :     PGresult   *res;
   10425             :     const char *query;
   10426             :     int         i;
   10427             : 
   10428         470 :     query = "SELECT oid, rolname FROM pg_catalog.pg_roles ORDER BY 1";
   10429             : 
   10430         470 :     res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK);
   10431             : 
   10432         470 :     nrolenames = PQntuples(res);
   10433             : 
   10434         470 :     rolenames = (RoleNameItem *) pg_malloc(nrolenames * sizeof(RoleNameItem));
   10435             : 
   10436       10180 :     for (i = 0; i < nrolenames; i++)
   10437             :     {
   10438        9710 :         rolenames[i].roleoid = atooid(PQgetvalue(res, i, 0));
   10439        9710 :         rolenames[i].rolename = pg_strdup(PQgetvalue(res, i, 1));
   10440             :     }
   10441             : 
   10442         470 :     PQclear(res);
   10443         470 : }
   10444             : 
   10445             : /*
   10446             :  * getAdditionalACLs
   10447             :  *
   10448             :  * We have now created all the DumpableObjects, and collected the ACL data
   10449             :  * that appears in the directly-associated catalog entries.  However, there's
   10450             :  * more ACL-related info to collect.  If any of a table's columns have ACLs,
   10451             :  * we must set the TableInfo's DUMP_COMPONENT_ACL components flag, as well as
   10452             :  * its hascolumnACLs flag (we won't store the ACLs themselves here, though).
   10453             :  * Also, in versions having the pg_init_privs catalog, read that and load the
   10454             :  * information into the relevant DumpableObjects.
   10455             :  */
   10456             : static void
   10457         464 : getAdditionalACLs(Archive *fout)
   10458             : {
   10459         464 :     PQExpBuffer query = createPQExpBuffer();
   10460             :     PGresult   *res;
   10461             :     int         ntups,
   10462             :                 i;
   10463             : 
   10464             :     /* Check for per-column ACLs */
   10465         464 :     appendPQExpBufferStr(query,
   10466             :                          "SELECT DISTINCT attrelid FROM pg_attribute "
   10467             :                          "WHERE attacl IS NOT NULL");
   10468             : 
   10469         464 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10470             : 
   10471         464 :     ntups = PQntuples(res);
   10472        1304 :     for (i = 0; i < ntups; i++)
   10473             :     {
   10474         840 :         Oid         relid = atooid(PQgetvalue(res, i, 0));
   10475             :         TableInfo  *tblinfo;
   10476             : 
   10477         840 :         tblinfo = findTableByOid(relid);
   10478             :         /* OK to ignore tables we haven't got a DumpableObject for */
   10479         840 :         if (tblinfo)
   10480             :         {
   10481         840 :             tblinfo->dobj.components |= DUMP_COMPONENT_ACL;
   10482         840 :             tblinfo->hascolumnACLs = true;
   10483             :         }
   10484             :     }
   10485         464 :     PQclear(res);
   10486             : 
   10487             :     /* Fetch initial-privileges data */
   10488         464 :     if (fout->remoteVersion >= 90600)
   10489             :     {
   10490         464 :         printfPQExpBuffer(query,
   10491             :                           "SELECT objoid, classoid, objsubid, privtype, initprivs "
   10492             :                           "FROM pg_init_privs");
   10493             : 
   10494         464 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10495             : 
   10496         464 :         ntups = PQntuples(res);
   10497      107800 :         for (i = 0; i < ntups; i++)
   10498             :         {
   10499      107336 :             Oid         objoid = atooid(PQgetvalue(res, i, 0));
   10500      107336 :             Oid         classoid = atooid(PQgetvalue(res, i, 1));
   10501      107336 :             int         objsubid = atoi(PQgetvalue(res, i, 2));
   10502      107336 :             char        privtype = *(PQgetvalue(res, i, 3));
   10503      107336 :             char       *initprivs = PQgetvalue(res, i, 4);
   10504             :             CatalogId   objId;
   10505             :             DumpableObject *dobj;
   10506             : 
   10507      107336 :             objId.tableoid = classoid;
   10508      107336 :             objId.oid = objoid;
   10509      107336 :             dobj = findObjectByCatalogId(objId);
   10510             :             /* OK to ignore entries we haven't got a DumpableObject for */
   10511      107336 :             if (dobj)
   10512             :             {
   10513             :                 /* Cope with sub-object initprivs */
   10514       76344 :                 if (objsubid != 0)
   10515             :                 {
   10516        7936 :                     if (dobj->objType == DO_TABLE)
   10517             :                     {
   10518             :                         /* For a column initprivs, set the table's ACL flags */
   10519        7936 :                         dobj->components |= DUMP_COMPONENT_ACL;
   10520        7936 :                         ((TableInfo *) dobj)->hascolumnACLs = true;
   10521             :                     }
   10522             :                     else
   10523           0 :                         pg_log_warning("unsupported pg_init_privs entry: %u %u %d",
   10524             :                                        classoid, objoid, objsubid);
   10525        8392 :                     continue;
   10526             :                 }
   10527             : 
   10528             :                 /*
   10529             :                  * We ignore any pg_init_privs.initprivs entry for the public
   10530             :                  * schema, as explained in getNamespaces().
   10531             :                  */
   10532       68408 :                 if (dobj->objType == DO_NAMESPACE &&
   10533         920 :                     strcmp(dobj->name, "public") == 0)
   10534         456 :                     continue;
   10535             : 
   10536             :                 /* Else it had better be of a type we think has ACLs */
   10537       67952 :                 if (dobj->objType == DO_NAMESPACE ||
   10538       67488 :                     dobj->objType == DO_TYPE ||
   10539       67440 :                     dobj->objType == DO_FUNC ||
   10540       67248 :                     dobj->objType == DO_AGG ||
   10541       67200 :                     dobj->objType == DO_TABLE ||
   10542           0 :                     dobj->objType == DO_PROCLANG ||
   10543           0 :                     dobj->objType == DO_FDW ||
   10544           0 :                     dobj->objType == DO_FOREIGN_SERVER)
   10545       67952 :                 {
   10546       67952 :                     DumpableObjectWithAcl *daobj = (DumpableObjectWithAcl *) dobj;
   10547             : 
   10548       67952 :                     daobj->dacl.privtype = privtype;
   10549       67952 :                     daobj->dacl.initprivs = pstrdup(initprivs);
   10550             :                 }
   10551             :                 else
   10552           0 :                     pg_log_warning("unsupported pg_init_privs entry: %u %u %d",
   10553             :                                    classoid, objoid, objsubid);
   10554             :             }
   10555             :         }
   10556         464 :         PQclear(res);
   10557             :     }
   10558             : 
   10559         464 :     destroyPQExpBuffer(query);
   10560         464 : }
   10561             : 
   10562             : /*
   10563             :  * dumpCommentExtended --
   10564             :  *
   10565             :  * This routine is used to dump any comments associated with the
   10566             :  * object handed to this routine. The routine takes the object type
   10567             :  * and object name (ready to print, except for schema decoration), plus
   10568             :  * the namespace and owner of the object (for labeling the ArchiveEntry),
   10569             :  * plus catalog ID and subid which are the lookup key for pg_description,
   10570             :  * plus the dump ID for the object (for setting a dependency).
   10571             :  * If a matching pg_description entry is found, it is dumped.
   10572             :  *
   10573             :  * Note: in some cases, such as comments for triggers and rules, the "type"
   10574             :  * string really looks like, e.g., "TRIGGER name ON".  This is a bit of a hack
   10575             :  * but it doesn't seem worth complicating the API for all callers to make
   10576             :  * it cleaner.
   10577             :  *
   10578             :  * Note: although this routine takes a dumpId for dependency purposes,
   10579             :  * that purpose is just to mark the dependency in the emitted dump file
   10580             :  * for possible future use by pg_restore.  We do NOT use it for determining
   10581             :  * ordering of the comment in the dump file, because this routine is called
   10582             :  * after dependency sorting occurs.  This routine should be called just after
   10583             :  * calling ArchiveEntry() for the specified object.
   10584             :  */
   10585             : static void
   10586       12874 : dumpCommentExtended(Archive *fout, const char *type,
   10587             :                     const char *name, const char *namespace,
   10588             :                     const char *owner, CatalogId catalogId,
   10589             :                     int subid, DumpId dumpId,
   10590             :                     const char *initdb_comment)
   10591             : {
   10592       12874 :     DumpOptions *dopt = fout->dopt;
   10593             :     CommentItem *comments;
   10594             :     int         ncomments;
   10595             : 
   10596             :     /* do nothing, if --no-comments is supplied */
   10597       12874 :     if (dopt->no_comments)
   10598           0 :         return;
   10599             : 
   10600             :     /* Comments are schema not data ... except LO comments are data */
   10601       12874 :     if (strcmp(type, "LARGE OBJECT") != 0)
   10602             :     {
   10603       12752 :         if (!dopt->dumpSchema)
   10604           0 :             return;
   10605             :     }
   10606             :     else
   10607             :     {
   10608             :         /* We do dump LO comments in binary-upgrade mode */
   10609         122 :         if (!dopt->dumpData && !dopt->binary_upgrade)
   10610           0 :             return;
   10611             :     }
   10612             : 
   10613             :     /* Search for comments associated with catalogId, using table */
   10614       12874 :     ncomments = findComments(catalogId.tableoid, catalogId.oid,
   10615             :                              &comments);
   10616             : 
   10617             :     /* Is there one matching the subid? */
   10618       12874 :     while (ncomments > 0)
   10619             :     {
   10620       12778 :         if (comments->objsubid == subid)
   10621       12778 :             break;
   10622           0 :         comments++;
   10623           0 :         ncomments--;
   10624             :     }
   10625             : 
   10626       12874 :     if (initdb_comment != NULL)
   10627             :     {
   10628             :         static CommentItem empty_comment = {.descr = ""};
   10629             : 
   10630             :         /*
   10631             :          * initdb creates this object with a comment.  Skip dumping the
   10632             :          * initdb-provided comment, which would complicate matters for
   10633             :          * non-superuser use of pg_dump.  When the DBA has removed initdb's
   10634             :          * comment, replicate that.
   10635             :          */
   10636         340 :         if (ncomments == 0)
   10637             :         {
   10638           8 :             comments = &empty_comment;
   10639           8 :             ncomments = 1;
   10640             :         }
   10641         332 :         else if (strcmp(comments->descr, initdb_comment) == 0)
   10642         332 :             ncomments = 0;
   10643             :     }
   10644             : 
   10645             :     /* If a comment exists, build COMMENT ON statement */
   10646       12874 :     if (ncomments > 0)
   10647             :     {
   10648       12454 :         PQExpBuffer query = createPQExpBuffer();
   10649       12454 :         PQExpBuffer tag = createPQExpBuffer();
   10650             : 
   10651       12454 :         appendPQExpBuffer(query, "COMMENT ON %s ", type);
   10652       12454 :         if (namespace && *namespace)
   10653       12096 :             appendPQExpBuffer(query, "%s.", fmtId(namespace));
   10654       12454 :         appendPQExpBuffer(query, "%s IS ", name);
   10655       12454 :         appendStringLiteralAH(query, comments->descr, fout);
   10656       12454 :         appendPQExpBufferStr(query, ";\n");
   10657             : 
   10658       12454 :         appendPQExpBuffer(tag, "%s %s", type, name);
   10659             : 
   10660             :         /*
   10661             :          * We mark comments as SECTION_NONE because they really belong in the
   10662             :          * same section as their parent, whether that is pre-data or
   10663             :          * post-data.
   10664             :          */
   10665       12454 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
   10666       12454 :                      ARCHIVE_OPTS(.tag = tag->data,
   10667             :                                   .namespace = namespace,
   10668             :                                   .owner = owner,
   10669             :                                   .description = "COMMENT",
   10670             :                                   .section = SECTION_NONE,
   10671             :                                   .createStmt = query->data,
   10672             :                                   .deps = &dumpId,
   10673             :                                   .nDeps = 1));
   10674             : 
   10675       12454 :         destroyPQExpBuffer(query);
   10676       12454 :         destroyPQExpBuffer(tag);
   10677             :     }
   10678             : }
   10679             : 
   10680             : /*
   10681             :  * dumpComment --
   10682             :  *
   10683             :  * Typical simplification of the above function.
   10684             :  */
   10685             : static inline void
   10686       12466 : dumpComment(Archive *fout, const char *type,
   10687             :             const char *name, const char *namespace,
   10688             :             const char *owner, CatalogId catalogId,
   10689             :             int subid, DumpId dumpId)
   10690             : {
   10691       12466 :     dumpCommentExtended(fout, type, name, namespace, owner,
   10692             :                         catalogId, subid, dumpId, NULL);
   10693       12466 : }
   10694             : 
   10695             : /*
   10696             :  * appendNamedArgument --
   10697             :  *
   10698             :  * Convenience routine for constructing parameters of the form:
   10699             :  * 'paraname', 'value'::type
   10700             :  */
   10701             : static void
   10702       66838 : appendNamedArgument(PQExpBuffer out, Archive *fout, const char *argname,
   10703             :                     const char *argtype, const char *argval)
   10704             : {
   10705       66838 :     appendPQExpBufferStr(out, ",\n\t");
   10706             : 
   10707       66838 :     appendStringLiteralAH(out, argname, fout);
   10708       66838 :     appendPQExpBufferStr(out, ", ");
   10709             : 
   10710       66838 :     appendStringLiteralAH(out, argval, fout);
   10711       66838 :     appendPQExpBuffer(out, "::%s", argtype);
   10712       66838 : }
   10713             : 
   10714             : /*
   10715             :  * fetchAttributeStats --
   10716             :  *
   10717             :  * Fetch next batch of attribute statistics for dumpRelationStats_dumper().
   10718             :  */
   10719             : static PGresult *
   10720        5178 : fetchAttributeStats(Archive *fout)
   10721             : {
   10722        5178 :     ArchiveHandle *AH = (ArchiveHandle *) fout;
   10723        5178 :     PQExpBuffer nspnames = createPQExpBuffer();
   10724        5178 :     PQExpBuffer relnames = createPQExpBuffer();
   10725        5178 :     int         count = 0;
   10726        5178 :     PGresult   *res = NULL;
   10727             :     static TocEntry *te;
   10728             :     static bool restarted;
   10729        5178 :     int         max_rels = MAX_ATTR_STATS_RELS;
   10730             : 
   10731             :     /*
   10732             :      * Our query for retrieving statistics for multiple relations uses WITH
   10733             :      * ORDINALITY and multi-argument UNNEST(), both of which were introduced
   10734             :      * in v9.4.  For older versions, we resort to gathering statistics for a
   10735             :      * single relation at a time.
   10736             :      */
   10737        5178 :     if (fout->remoteVersion < 90400)
   10738           0 :         max_rels = 1;
   10739             : 
   10740             :     /* If we're just starting, set our TOC pointer. */
   10741        5178 :     if (!te)
   10742         288 :         te = AH->toc->next;
   10743             : 
   10744             :     /*
   10745             :      * We can't easily avoid a second TOC scan for the tar format because it
   10746             :      * writes restore.sql separately, which means we must execute the queries
   10747             :      * twice.  This feels risky, but there is no known reason it should
   10748             :      * generate different output than the first pass.  Even if it does, the
   10749             :      * worst-case scenario is that restore.sql might have different statistics
   10750             :      * data than the archive.
   10751             :      */
   10752        5178 :     if (!restarted && te == AH->toc && AH->format == archTar)
   10753             :     {
   10754          16 :         te = AH->toc->next;
   10755          16 :         restarted = true;
   10756             :     }
   10757             : 
   10758             :     /*
   10759             :      * Scan the TOC for the next set of relevant stats entries.  We assume
   10760             :      * that statistics are dumped in the order they are listed in the TOC.
   10761             :      * This is perhaps not the sturdiest assumption, so we verify it matches
   10762             :      * reality in dumpRelationStats_dumper().
   10763             :      */
   10764      103414 :     for (; te != AH->toc && count < max_rels; te = te->next)
   10765             :     {
   10766       98236 :         if ((te->reqs & REQ_STATS) != 0 &&
   10767       18412 :             strcmp(te->desc, "STATISTICS DATA") == 0)
   10768             :         {
   10769       18412 :             appendPQExpBuffer(nspnames, "%s%s", count ? "," : "",
   10770       18412 :                               fmtId(te->namespace));
   10771       18412 :             appendPQExpBuffer(relnames, "%s%s", count ? "," : "",
   10772       18412 :                               fmtId(te->tag));
   10773       18412 :             count++;
   10774             :         }
   10775             :     }
   10776             : 
   10777             :     /* Execute the query for the next batch of relations. */
   10778        5178 :     if (count > 0)
   10779             :     {
   10780         496 :         PQExpBuffer query = createPQExpBuffer();
   10781             : 
   10782         496 :         appendPQExpBuffer(query, "EXECUTE getAttributeStats("
   10783             :                           "'{%s}'::pg_catalog.name[],"
   10784             :                           "'{%s}'::pg_catalog.name[])",
   10785             :                           nspnames->data, relnames->data);
   10786         496 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   10787         496 :         destroyPQExpBuffer(query);
   10788             :     }
   10789             : 
   10790        5178 :     destroyPQExpBuffer(nspnames);
   10791        5178 :     destroyPQExpBuffer(relnames);
   10792        5178 :     return res;
   10793             : }
   10794             : 
   10795             : /*
   10796             :  * dumpRelationStats_dumper --
   10797             :  *
   10798             :  * Generate command to import stats into the relation on the new database.
   10799             :  * This routine is called by the Archiver when it wants the statistics to be
   10800             :  * dumped.
   10801             :  */
   10802             : static char *
   10803       18412 : dumpRelationStats_dumper(Archive *fout, const void *userArg, const TocEntry *te)
   10804             : {
   10805       18412 :     const RelStatsInfo *rsinfo = (RelStatsInfo *) userArg;
   10806             :     static PGresult *res;
   10807             :     static int  rownum;
   10808             :     PQExpBuffer query;
   10809             :     PQExpBufferData out_data;
   10810       18412 :     PQExpBuffer out = &out_data;
   10811             :     int         i_schemaname;
   10812             :     int         i_tablename;
   10813             :     int         i_attname;
   10814             :     int         i_inherited;
   10815             :     int         i_null_frac;
   10816             :     int         i_avg_width;
   10817             :     int         i_n_distinct;
   10818             :     int         i_most_common_vals;
   10819             :     int         i_most_common_freqs;
   10820             :     int         i_histogram_bounds;
   10821             :     int         i_correlation;
   10822             :     int         i_most_common_elems;
   10823             :     int         i_most_common_elem_freqs;
   10824             :     int         i_elem_count_histogram;
   10825             :     int         i_range_length_histogram;
   10826             :     int         i_range_empty_frac;
   10827             :     int         i_range_bounds_histogram;
   10828             :     static TocEntry *expected_te;
   10829             : 
   10830             :     /*
   10831             :      * fetchAttributeStats() assumes that the statistics are dumped in the
   10832             :      * order they are listed in the TOC.  We verify that here for safety.
   10833             :      */
   10834       18412 :     if (!expected_te)
   10835         288 :         expected_te = ((ArchiveHandle *) fout)->toc;
   10836             : 
   10837       18412 :     expected_te = expected_te->next;
   10838       92372 :     while ((expected_te->reqs & REQ_STATS) == 0 ||
   10839       18412 :            strcmp(expected_te->desc, "STATISTICS DATA") != 0)
   10840       73960 :         expected_te = expected_te->next;
   10841             : 
   10842       18412 :     if (te != expected_te)
   10843           0 :         pg_fatal("stats dumped out of order (current: %d %s %s) (expected: %d %s %s)",
   10844             :                  te->dumpId, te->desc, te->tag,
   10845             :                  expected_te->dumpId, expected_te->desc, expected_te->tag);
   10846             : 
   10847       18412 :     query = createPQExpBuffer();
   10848       18412 :     if (!fout->is_prepared[PREPQUERY_GETATTRIBUTESTATS])
   10849             :     {
   10850         288 :         appendPQExpBufferStr(query,
   10851             :                              "PREPARE getAttributeStats(pg_catalog.name[], pg_catalog.name[]) AS\n"
   10852             :                              "SELECT s.schemaname, s.tablename, s.attname, s.inherited, "
   10853             :                              "s.null_frac, s.avg_width, s.n_distinct, "
   10854             :                              "s.most_common_vals, s.most_common_freqs, "
   10855             :                              "s.histogram_bounds, s.correlation, "
   10856             :                              "s.most_common_elems, s.most_common_elem_freqs, "
   10857             :                              "s.elem_count_histogram, ");
   10858             : 
   10859         288 :         if (fout->remoteVersion >= 170000)
   10860         288 :             appendPQExpBufferStr(query,
   10861             :                                  "s.range_length_histogram, "
   10862             :                                  "s.range_empty_frac, "
   10863             :                                  "s.range_bounds_histogram ");
   10864             :         else
   10865           0 :             appendPQExpBufferStr(query,
   10866             :                                  "NULL AS range_length_histogram,"
   10867             :                                  "NULL AS range_empty_frac,"
   10868             :                                  "NULL AS range_bounds_histogram ");
   10869             : 
   10870             :         /*
   10871             :          * The results must be in the order of the relations supplied in the
   10872             :          * parameters to ensure we remain in sync as we walk through the TOC.
   10873             :          * The redundant filter clause on s.tablename = ANY(...) seems
   10874             :          * sufficient to convince the planner to use
   10875             :          * pg_class_relname_nsp_index, which avoids a full scan of pg_stats.
   10876             :          * This may not work for all versions.
   10877             :          *
   10878             :          * Our query for retrieving statistics for multiple relations uses
   10879             :          * WITH ORDINALITY and multi-argument UNNEST(), both of which were
   10880             :          * introduced in v9.4.  For older versions, we resort to gathering
   10881             :          * statistics for a single relation at a time.
   10882             :          */
   10883         288 :         if (fout->remoteVersion >= 90400)
   10884         288 :             appendPQExpBufferStr(query,
   10885             :                                  "FROM pg_catalog.pg_stats s "
   10886             :                                  "JOIN unnest($1, $2) WITH ORDINALITY AS u (schemaname, tablename, ord) "
   10887             :                                  "ON s.schemaname = u.schemaname "
   10888             :                                  "AND s.tablename = u.tablename "
   10889             :                                  "WHERE s.tablename = ANY($2) "
   10890             :                                  "ORDER BY u.ord, s.attname, s.inherited");
   10891             :         else
   10892           0 :             appendPQExpBufferStr(query,
   10893             :                                  "FROM pg_catalog.pg_stats s "
   10894             :                                  "WHERE s.schemaname = $1[1] "
   10895             :                                  "AND s.tablename = $2[1] "
   10896             :                                  "ORDER BY s.attname, s.inherited");
   10897             : 
   10898         288 :         ExecuteSqlStatement(fout, query->data);
   10899             : 
   10900         288 :         fout->is_prepared[PREPQUERY_GETATTRIBUTESTATS] = true;
   10901         288 :         resetPQExpBuffer(query);
   10902             :     }
   10903             : 
   10904       18412 :     initPQExpBuffer(out);
   10905             : 
   10906             :     /* restore relation stats */
   10907       18412 :     appendPQExpBufferStr(out, "SELECT * FROM pg_catalog.pg_restore_relation_stats(\n");
   10908       18412 :     appendPQExpBuffer(out, "\t'version', '%d'::integer,\n",
   10909             :                       fout->remoteVersion);
   10910       18412 :     appendPQExpBufferStr(out, "\t'schemaname', ");
   10911       18412 :     appendStringLiteralAH(out, rsinfo->dobj.namespace->dobj.name, fout);
   10912       18412 :     appendPQExpBufferStr(out, ",\n");
   10913       18412 :     appendPQExpBufferStr(out, "\t'relname', ");
   10914       18412 :     appendStringLiteralAH(out, rsinfo->dobj.name, fout);
   10915       18412 :     appendPQExpBufferStr(out, ",\n");
   10916       18412 :     appendPQExpBuffer(out, "\t'relpages', '%d'::integer,\n", rsinfo->relpages);
   10917       18412 :     appendPQExpBuffer(out, "\t'reltuples', '%s'::real,\n", rsinfo->reltuples);
   10918       18412 :     appendPQExpBuffer(out, "\t'relallvisible', '%d'::integer",
   10919             :                       rsinfo->relallvisible);
   10920             : 
   10921       18412 :     if (fout->remoteVersion >= 180000)
   10922       18412 :         appendPQExpBuffer(out, ",\n\t'relallfrozen', '%d'::integer", rsinfo->relallfrozen);
   10923             : 
   10924       18412 :     appendPQExpBufferStr(out, "\n);\n");
   10925             : 
   10926             :     /* Fetch the next batch of attribute statistics if needed. */
   10927       18412 :     if (rownum >= PQntuples(res))
   10928             :     {
   10929        5178 :         PQclear(res);
   10930        5178 :         res = fetchAttributeStats(fout);
   10931        5178 :         rownum = 0;
   10932             :     }
   10933             : 
   10934       18412 :     i_schemaname = PQfnumber(res, "schemaname");
   10935       18412 :     i_tablename = PQfnumber(res, "tablename");
   10936       18412 :     i_attname = PQfnumber(res, "attname");
   10937       18412 :     i_inherited = PQfnumber(res, "inherited");
   10938       18412 :     i_null_frac = PQfnumber(res, "null_frac");
   10939       18412 :     i_avg_width = PQfnumber(res, "avg_width");
   10940       18412 :     i_n_distinct = PQfnumber(res, "n_distinct");
   10941       18412 :     i_most_common_vals = PQfnumber(res, "most_common_vals");
   10942       18412 :     i_most_common_freqs = PQfnumber(res, "most_common_freqs");
   10943       18412 :     i_histogram_bounds = PQfnumber(res, "histogram_bounds");
   10944       18412 :     i_correlation = PQfnumber(res, "correlation");
   10945       18412 :     i_most_common_elems = PQfnumber(res, "most_common_elems");
   10946       18412 :     i_most_common_elem_freqs = PQfnumber(res, "most_common_elem_freqs");
   10947       18412 :     i_elem_count_histogram = PQfnumber(res, "elem_count_histogram");
   10948       18412 :     i_range_length_histogram = PQfnumber(res, "range_length_histogram");
   10949       18412 :     i_range_empty_frac = PQfnumber(res, "range_empty_frac");
   10950       18412 :     i_range_bounds_histogram = PQfnumber(res, "range_bounds_histogram");
   10951             : 
   10952             :     /* restore attribute stats */
   10953       28514 :     for (; rownum < PQntuples(res); rownum++)
   10954             :     {
   10955             :         const char *attname;
   10956             : 
   10957             :         /* Stop if the next stat row in our cache isn't for this relation. */
   10958       23336 :         if (strcmp(te->tag, PQgetvalue(res, rownum, i_tablename)) != 0 ||
   10959       10102 :             strcmp(te->namespace, PQgetvalue(res, rownum, i_schemaname)) != 0)
   10960             :             break;
   10961             : 
   10962       10102 :         appendPQExpBufferStr(out, "SELECT * FROM pg_catalog.pg_restore_attribute_stats(\n");
   10963       10102 :         appendPQExpBuffer(out, "\t'version', '%d'::integer,\n",
   10964             :                           fout->remoteVersion);
   10965       10102 :         appendPQExpBufferStr(out, "\t'schemaname', ");
   10966       10102 :         appendStringLiteralAH(out, rsinfo->dobj.namespace->dobj.name, fout);
   10967       10102 :         appendPQExpBufferStr(out, ",\n\t'relname', ");
   10968       10102 :         appendStringLiteralAH(out, rsinfo->dobj.name, fout);
   10969             : 
   10970       10102 :         if (PQgetisnull(res, rownum, i_attname))
   10971           0 :             pg_fatal("attname cannot be NULL");
   10972       10102 :         attname = PQgetvalue(res, rownum, i_attname);
   10973             : 
   10974             :         /*
   10975             :          * Indexes look up attname in indAttNames to derive attnum, all others
   10976             :          * use attname directly.  We must specify attnum for indexes, since
   10977             :          * their attnames are not necessarily stable across dump/reload.
   10978             :          */
   10979       10102 :         if (rsinfo->nindAttNames == 0)
   10980             :         {
   10981        9982 :             appendPQExpBufferStr(out, ",\n\t'attname', ");
   10982        9982 :             appendStringLiteralAH(out, attname, fout);
   10983             :         }
   10984             :         else
   10985             :         {
   10986         120 :             bool        found = false;
   10987             : 
   10988         192 :             for (int i = 0; i < rsinfo->nindAttNames; i++)
   10989             :             {
   10990         192 :                 if (strcmp(attname, rsinfo->indAttNames[i]) == 0)
   10991             :                 {
   10992         120 :                     appendPQExpBuffer(out, ",\n\t'attnum', '%d'::smallint",
   10993             :                                       i + 1);
   10994         120 :                     found = true;
   10995         120 :                     break;
   10996             :                 }
   10997             :             }
   10998             : 
   10999         120 :             if (!found)
   11000           0 :                 pg_fatal("could not find index attname \"%s\"", attname);
   11001             :         }
   11002             : 
   11003       10102 :         if (!PQgetisnull(res, rownum, i_inherited))
   11004       10102 :             appendNamedArgument(out, fout, "inherited", "boolean",
   11005       10102 :                                 PQgetvalue(res, rownum, i_inherited));
   11006       10102 :         if (!PQgetisnull(res, rownum, i_null_frac))
   11007       10102 :             appendNamedArgument(out, fout, "null_frac", "real",
   11008       10102 :                                 PQgetvalue(res, rownum, i_null_frac));
   11009       10102 :         if (!PQgetisnull(res, rownum, i_avg_width))
   11010       10102 :             appendNamedArgument(out, fout, "avg_width", "integer",
   11011       10102 :                                 PQgetvalue(res, rownum, i_avg_width));
   11012       10102 :         if (!PQgetisnull(res, rownum, i_n_distinct))
   11013       10102 :             appendNamedArgument(out, fout, "n_distinct", "real",
   11014       10102 :                                 PQgetvalue(res, rownum, i_n_distinct));
   11015       10102 :         if (!PQgetisnull(res, rownum, i_most_common_vals))
   11016        5802 :             appendNamedArgument(out, fout, "most_common_vals", "text",
   11017        5802 :                                 PQgetvalue(res, rownum, i_most_common_vals));
   11018       10102 :         if (!PQgetisnull(res, rownum, i_most_common_freqs))
   11019        5802 :             appendNamedArgument(out, fout, "most_common_freqs", "real[]",
   11020        5802 :                                 PQgetvalue(res, rownum, i_most_common_freqs));
   11021       10102 :         if (!PQgetisnull(res, rownum, i_histogram_bounds))
   11022        4926 :             appendNamedArgument(out, fout, "histogram_bounds", "text",
   11023        4926 :                                 PQgetvalue(res, rownum, i_histogram_bounds));
   11024       10102 :         if (!PQgetisnull(res, rownum, i_correlation))
   11025        9330 :             appendNamedArgument(out, fout, "correlation", "real",
   11026        9330 :                                 PQgetvalue(res, rownum, i_correlation));
   11027       10102 :         if (!PQgetisnull(res, rownum, i_most_common_elems))
   11028         158 :             appendNamedArgument(out, fout, "most_common_elems", "text",
   11029         158 :                                 PQgetvalue(res, rownum, i_most_common_elems));
   11030       10102 :         if (!PQgetisnull(res, rownum, i_most_common_elem_freqs))
   11031         158 :             appendNamedArgument(out, fout, "most_common_elem_freqs", "real[]",
   11032         158 :                                 PQgetvalue(res, rownum, i_most_common_elem_freqs));
   11033       10102 :         if (!PQgetisnull(res, rownum, i_elem_count_histogram))
   11034         146 :             appendNamedArgument(out, fout, "elem_count_histogram", "real[]",
   11035         146 :                                 PQgetvalue(res, rownum, i_elem_count_histogram));
   11036       10102 :         if (fout->remoteVersion >= 170000)
   11037             :         {
   11038       10102 :             if (!PQgetisnull(res, rownum, i_range_length_histogram))
   11039          36 :                 appendNamedArgument(out, fout, "range_length_histogram", "text",
   11040          36 :                                     PQgetvalue(res, rownum, i_range_length_histogram));
   11041       10102 :             if (!PQgetisnull(res, rownum, i_range_empty_frac))
   11042          36 :                 appendNamedArgument(out, fout, "range_empty_frac", "real",
   11043          36 :                                     PQgetvalue(res, rownum, i_range_empty_frac));
   11044       10102 :             if (!PQgetisnull(res, rownum, i_range_bounds_histogram))
   11045          36 :                 appendNamedArgument(out, fout, "range_bounds_histogram", "text",
   11046          36 :                                     PQgetvalue(res, rownum, i_range_bounds_histogram));
   11047             :         }
   11048       10102 :         appendPQExpBufferStr(out, "\n);\n");
   11049             :     }
   11050             : 
   11051       18412 :     destroyPQExpBuffer(query);
   11052       18412 :     return out->data;
   11053             : }
   11054             : 
   11055             : /*
   11056             :  * dumpRelationStats --
   11057             :  *
   11058             :  * Make an ArchiveEntry for the relation statistics.  The Archiver will take
   11059             :  * care of gathering the statistics and generating the restore commands when
   11060             :  * they are needed.
   11061             :  */
   11062             : static void
   11063       18518 : dumpRelationStats(Archive *fout, const RelStatsInfo *rsinfo)
   11064             : {
   11065       18518 :     const DumpableObject *dobj = &rsinfo->dobj;
   11066             : 
   11067             :     /* nothing to do if we are not dumping statistics */
   11068       18518 :     if (!fout->dopt->dumpStatistics)
   11069           0 :         return;
   11070             : 
   11071       18518 :     ArchiveEntry(fout, nilCatalogId, createDumpId(),
   11072       18518 :                  ARCHIVE_OPTS(.tag = dobj->name,
   11073             :                               .namespace = dobj->namespace->dobj.name,
   11074             :                               .description = "STATISTICS DATA",
   11075             :                               .section = rsinfo->section,
   11076             :                               .defnFn = dumpRelationStats_dumper,
   11077             :                               .defnArg = rsinfo,
   11078             :                               .deps = dobj->dependencies,
   11079             :                               .nDeps = dobj->nDeps));
   11080             : }
   11081             : 
   11082             : /*
   11083             :  * dumpTableComment --
   11084             :  *
   11085             :  * As above, but dump comments for both the specified table (or view)
   11086             :  * and its columns.
   11087             :  */
   11088             : static void
   11089         176 : dumpTableComment(Archive *fout, const TableInfo *tbinfo,
   11090             :                  const char *reltypename)
   11091             : {
   11092         176 :     DumpOptions *dopt = fout->dopt;
   11093             :     CommentItem *comments;
   11094             :     int         ncomments;
   11095             :     PQExpBuffer query;
   11096             :     PQExpBuffer tag;
   11097             : 
   11098             :     /* do nothing, if --no-comments is supplied */
   11099         176 :     if (dopt->no_comments)
   11100           0 :         return;
   11101             : 
   11102             :     /* Comments are SCHEMA not data */
   11103         176 :     if (!dopt->dumpSchema)
   11104           0 :         return;
   11105             : 
   11106             :     /* Search for comments associated with relation, using table */
   11107         176 :     ncomments = findComments(tbinfo->dobj.catId.tableoid,
   11108             :                              tbinfo->dobj.catId.oid,
   11109             :                              &comments);
   11110             : 
   11111             :     /* If comments exist, build COMMENT ON statements */
   11112         176 :     if (ncomments <= 0)
   11113           0 :         return;
   11114             : 
   11115         176 :     query = createPQExpBuffer();
   11116         176 :     tag = createPQExpBuffer();
   11117             : 
   11118         496 :     while (ncomments > 0)
   11119             :     {
   11120         320 :         const char *descr = comments->descr;
   11121         320 :         int         objsubid = comments->objsubid;
   11122             : 
   11123         320 :         if (objsubid == 0)
   11124             :         {
   11125          72 :             resetPQExpBuffer(tag);
   11126          72 :             appendPQExpBuffer(tag, "%s %s", reltypename,
   11127          72 :                               fmtId(tbinfo->dobj.name));
   11128             : 
   11129          72 :             resetPQExpBuffer(query);
   11130          72 :             appendPQExpBuffer(query, "COMMENT ON %s %s IS ", reltypename,
   11131          72 :                               fmtQualifiedDumpable(tbinfo));
   11132          72 :             appendStringLiteralAH(query, descr, fout);
   11133          72 :             appendPQExpBufferStr(query, ";\n");
   11134             : 
   11135          72 :             ArchiveEntry(fout, nilCatalogId, createDumpId(),
   11136          72 :                          ARCHIVE_OPTS(.tag = tag->data,
   11137             :                                       .namespace = tbinfo->dobj.namespace->dobj.name,
   11138             :                                       .owner = tbinfo->rolname,
   11139             :                                       .description = "COMMENT",
   11140             :                                       .section = SECTION_NONE,
   11141             :                                       .createStmt = query->data,
   11142             :                                       .deps = &(tbinfo->dobj.dumpId),
   11143             :                                       .nDeps = 1));
   11144             :         }
   11145         248 :         else if (objsubid > 0 && objsubid <= tbinfo->numatts)
   11146             :         {
   11147         248 :             resetPQExpBuffer(tag);
   11148         248 :             appendPQExpBuffer(tag, "COLUMN %s.",
   11149         248 :                               fmtId(tbinfo->dobj.name));
   11150         248 :             appendPQExpBufferStr(tag, fmtId(tbinfo->attnames[objsubid - 1]));
   11151             : 
   11152         248 :             resetPQExpBuffer(query);
   11153         248 :             appendPQExpBuffer(query, "COMMENT ON COLUMN %s.",
   11154         248 :                               fmtQualifiedDumpable(tbinfo));
   11155         248 :             appendPQExpBuffer(query, "%s IS ",
   11156         248 :                               fmtId(tbinfo->attnames[objsubid - 1]));
   11157         248 :             appendStringLiteralAH(query, descr, fout);
   11158         248 :             appendPQExpBufferStr(query, ";\n");
   11159             : 
   11160         248 :             ArchiveEntry(fout, nilCatalogId, createDumpId(),
   11161         248 :                          ARCHIVE_OPTS(.tag = tag->data,
   11162             :                                       .namespace = tbinfo->dobj.namespace->dobj.name,
   11163             :                                       .owner = tbinfo->rolname,
   11164             :                                       .description = "COMMENT",
   11165             :                                       .section = SECTION_NONE,
   11166             :                                       .createStmt = query->data,
   11167             :                                       .deps = &(tbinfo->dobj.dumpId),
   11168             :                                       .nDeps = 1));
   11169             :         }
   11170             : 
   11171         320 :         comments++;
   11172         320 :         ncomments--;
   11173             :     }
   11174             : 
   11175         176 :     destroyPQExpBuffer(query);
   11176         176 :     destroyPQExpBuffer(tag);
   11177             : }
   11178             : 
   11179             : /*
   11180             :  * findComments --
   11181             :  *
   11182             :  * Find the comment(s), if any, associated with the given object.  All the
   11183             :  * objsubid values associated with the given classoid/objoid are found with
   11184             :  * one search.
   11185             :  */
   11186             : static int
   11187       13122 : findComments(Oid classoid, Oid objoid, CommentItem **items)
   11188             : {
   11189       13122 :     CommentItem *middle = NULL;
   11190             :     CommentItem *low;
   11191             :     CommentItem *high;
   11192             :     int         nmatch;
   11193             : 
   11194             :     /*
   11195             :      * Do binary search to find some item matching the object.
   11196             :      */
   11197       13122 :     low = &comments[0];
   11198       13122 :     high = &comments[ncomments - 1];
   11199      130184 :     while (low <= high)
   11200             :     {
   11201      130088 :         middle = low + (high - low) / 2;
   11202             : 
   11203      130088 :         if (classoid < middle->classoid)
   11204       14778 :             high = middle - 1;
   11205      115310 :         else if (classoid > middle->classoid)
   11206       14842 :             low = middle + 1;
   11207      100468 :         else if (objoid < middle->objoid)
   11208       42260 :             high = middle - 1;
   11209       58208 :         else if (objoid > middle->objoid)
   11210       45182 :             low = middle + 1;
   11211             :         else
   11212       13026 :             break;              /* found a match */
   11213             :     }
   11214             : 
   11215       13122 :     if (low > high)              /* no matches */
   11216             :     {
   11217          96 :         *items = NULL;
   11218          96 :         return 0;
   11219             :     }
   11220             : 
   11221             :     /*
   11222             :      * Now determine how many items match the object.  The search loop
   11223             :      * invariant still holds: only items between low and high inclusive could
   11224             :      * match.
   11225             :      */
   11226       13026 :     nmatch = 1;
   11227       13026 :     while (middle > low)
   11228             :     {
   11229        6288 :         if (classoid != middle[-1].classoid ||
   11230        6044 :             objoid != middle[-1].objoid)
   11231             :             break;
   11232           0 :         middle--;
   11233           0 :         nmatch++;
   11234             :     }
   11235             : 
   11236       13026 :     *items = middle;
   11237             : 
   11238       13026 :     middle += nmatch;
   11239       13170 :     while (middle <= high)
   11240             :     {
   11241        7202 :         if (classoid != middle->classoid ||
   11242        6300 :             objoid != middle->objoid)
   11243             :             break;
   11244         144 :         middle++;
   11245         144 :         nmatch++;
   11246             :     }
   11247             : 
   11248       13026 :     return nmatch;
   11249             : }
   11250             : 
   11251             : /*
   11252             :  * collectComments --
   11253             :  *
   11254             :  * Construct a table of all comments available for database objects;
   11255             :  * also set the has-comment component flag for each relevant object.
   11256             :  *
   11257             :  * We used to do per-object queries for the comments, but it's much faster
   11258             :  * to pull them all over at once, and on most databases the memory cost
   11259             :  * isn't high.
   11260             :  *
   11261             :  * The table is sorted by classoid/objid/objsubid for speed in lookup.
   11262             :  */
   11263             : static void
   11264         468 : collectComments(Archive *fout)
   11265             : {
   11266             :     PGresult   *res;
   11267             :     PQExpBuffer query;
   11268             :     int         i_description;
   11269             :     int         i_classoid;
   11270             :     int         i_objoid;
   11271             :     int         i_objsubid;
   11272             :     int         ntups;
   11273             :     int         i;
   11274             :     DumpableObject *dobj;
   11275             : 
   11276         468 :     query = createPQExpBuffer();
   11277             : 
   11278         468 :     appendPQExpBufferStr(query, "SELECT description, classoid, objoid, objsubid "
   11279             :                          "FROM pg_catalog.pg_description "
   11280             :                          "ORDER BY classoid, objoid, objsubid");
   11281             : 
   11282         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   11283             : 
   11284             :     /* Construct lookup table containing OIDs in numeric form */
   11285             : 
   11286         468 :     i_description = PQfnumber(res, "description");
   11287         468 :     i_classoid = PQfnumber(res, "classoid");
   11288         468 :     i_objoid = PQfnumber(res, "objoid");
   11289         468 :     i_objsubid = PQfnumber(res, "objsubid");
   11290             : 
   11291         468 :     ntups = PQntuples(res);
   11292             : 
   11293         468 :     comments = (CommentItem *) pg_malloc(ntups * sizeof(CommentItem));
   11294         468 :     ncomments = 0;
   11295         468 :     dobj = NULL;
   11296             : 
   11297     2479390 :     for (i = 0; i < ntups; i++)
   11298             :     {
   11299             :         CatalogId   objId;
   11300             :         int         subid;
   11301             : 
   11302     2478922 :         objId.tableoid = atooid(PQgetvalue(res, i, i_classoid));
   11303     2478922 :         objId.oid = atooid(PQgetvalue(res, i, i_objoid));
   11304     2478922 :         subid = atoi(PQgetvalue(res, i, i_objsubid));
   11305             : 
   11306             :         /* We needn't remember comments that don't match any dumpable object */
   11307     2478922 :         if (dobj == NULL ||
   11308      887202 :             dobj->catId.tableoid != objId.tableoid ||
   11309      881522 :             dobj->catId.oid != objId.oid)
   11310     2478726 :             dobj = findObjectByCatalogId(objId);
   11311     2478922 :         if (dobj == NULL)
   11312     1591268 :             continue;
   11313             : 
   11314             :         /*
   11315             :          * Comments on columns of composite types are linked to the type's
   11316             :          * pg_class entry, but we need to set the DUMP_COMPONENT_COMMENT flag
   11317             :          * in the type's own DumpableObject.
   11318             :          */
   11319      887654 :         if (subid != 0 && dobj->objType == DO_TABLE &&
   11320         432 :             ((TableInfo *) dobj)->relkind == RELKIND_COMPOSITE_TYPE)
   11321          98 :         {
   11322             :             TypeInfo   *cTypeInfo;
   11323             : 
   11324          98 :             cTypeInfo = findTypeByOid(((TableInfo *) dobj)->reltype);
   11325          98 :             if (cTypeInfo)
   11326          98 :                 cTypeInfo->dobj.components |= DUMP_COMPONENT_COMMENT;
   11327             :         }
   11328             :         else
   11329      887556 :             dobj->components |= DUMP_COMPONENT_COMMENT;
   11330             : 
   11331      887654 :         comments[ncomments].descr = pg_strdup(PQgetvalue(res, i, i_description));
   11332      887654 :         comments[ncomments].classoid = objId.tableoid;
   11333      887654 :         comments[ncomments].objoid = objId.oid;
   11334      887654 :         comments[ncomments].objsubid = subid;
   11335      887654 :         ncomments++;
   11336             :     }
   11337             : 
   11338         468 :     PQclear(res);
   11339         468 :     destroyPQExpBuffer(query);
   11340         468 : }
   11341             : 
   11342             : /*
   11343             :  * dumpDumpableObject
   11344             :  *
   11345             :  * This routine and its subsidiaries are responsible for creating
   11346             :  * ArchiveEntries (TOC objects) for each object to be dumped.
   11347             :  */
   11348             : static void
   11349     1731254 : dumpDumpableObject(Archive *fout, DumpableObject *dobj)
   11350             : {
   11351             :     /*
   11352             :      * Clear any dump-request bits for components that don't exist for this
   11353             :      * object.  (This makes it safe to initially use DUMP_COMPONENT_ALL as the
   11354             :      * request for every kind of object.)
   11355             :      */
   11356     1731254 :     dobj->dump &= dobj->components;
   11357             : 
   11358             :     /* Now, short-circuit if there's nothing to be done here. */
   11359     1731254 :     if (dobj->dump == 0)
   11360     1525444 :         return;
   11361             : 
   11362      205810 :     switch (dobj->objType)
   11363             :     {
   11364        1218 :         case DO_NAMESPACE:
   11365        1218 :             dumpNamespace(fout, (const NamespaceInfo *) dobj);
   11366        1218 :             break;
   11367          38 :         case DO_EXTENSION:
   11368          38 :             dumpExtension(fout, (const ExtensionInfo *) dobj);
   11369          38 :             break;
   11370        2148 :         case DO_TYPE:
   11371        2148 :             dumpType(fout, (const TypeInfo *) dobj);
   11372        2148 :             break;
   11373         196 :         case DO_SHELL_TYPE:
   11374         196 :             dumpShellType(fout, (const ShellTypeInfo *) dobj);
   11375         196 :             break;
   11376        5376 :         case DO_FUNC:
   11377        5376 :             dumpFunc(fout, (const FuncInfo *) dobj);
   11378        5376 :             break;
   11379         874 :         case DO_AGG:
   11380         874 :             dumpAgg(fout, (const AggInfo *) dobj);
   11381         874 :             break;
   11382        5098 :         case DO_OPERATOR:
   11383        5098 :             dumpOpr(fout, (const OprInfo *) dobj);
   11384        5098 :             break;
   11385         182 :         case DO_ACCESS_METHOD:
   11386         182 :             dumpAccessMethod(fout, (const AccessMethodInfo *) dobj);
   11387         182 :             break;
   11388        1362 :         case DO_OPCLASS:
   11389        1362 :             dumpOpclass(fout, (const OpclassInfo *) dobj);
   11390        1362 :             break;
   11391        1156 :         case DO_OPFAMILY:
   11392        1156 :             dumpOpfamily(fout, (const OpfamilyInfo *) dobj);
   11393        1156 :             break;
   11394        4970 :         case DO_COLLATION:
   11395        4970 :             dumpCollation(fout, (const CollInfo *) dobj);
   11396        4970 :             break;
   11397         852 :         case DO_CONVERSION:
   11398         852 :             dumpConversion(fout, (const ConvInfo *) dobj);
   11399         852 :             break;
   11400       80208 :         case DO_TABLE:
   11401       80208 :             dumpTable(fout, (const TableInfo *) dobj);
   11402       80208 :             break;
   11403        3900 :         case DO_TABLE_ATTACH:
   11404        3900 :             dumpTableAttach(fout, (const TableAttachInfo *) dobj);
   11405        3900 :             break;
   11406        2900 :         case DO_ATTRDEF:
   11407        2900 :             dumpAttrDef(fout, (const AttrDefInfo *) dobj);
   11408        2900 :             break;
   11409        6938 :         case DO_INDEX:
   11410        6938 :             dumpIndex(fout, (const IndxInfo *) dobj);
   11411        6938 :             break;
   11412        1480 :         case DO_INDEX_ATTACH:
   11413        1480 :             dumpIndexAttach(fout, (const IndexAttachInfo *) dobj);
   11414        1480 :             break;
   11415         314 :         case DO_STATSEXT:
   11416         314 :             dumpStatisticsExt(fout, (const StatsExtInfo *) dobj);
   11417         314 :             break;
   11418         852 :         case DO_REFRESH_MATVIEW:
   11419         852 :             refreshMatViewData(fout, (const TableDataInfo *) dobj);
   11420         852 :             break;
   11421        2968 :         case DO_RULE:
   11422        2968 :             dumpRule(fout, (const RuleInfo *) dobj);
   11423        2968 :             break;
   11424        1476 :         case DO_TRIGGER:
   11425        1476 :             dumpTrigger(fout, (const TriggerInfo *) dobj);
   11426        1476 :             break;
   11427          98 :         case DO_EVENT_TRIGGER:
   11428          98 :             dumpEventTrigger(fout, (const EventTriggerInfo *) dobj);
   11429          98 :             break;
   11430        5866 :         case DO_CONSTRAINT:
   11431        5866 :             dumpConstraint(fout, (const ConstraintInfo *) dobj);
   11432        5866 :             break;
   11433         472 :         case DO_FK_CONSTRAINT:
   11434         472 :             dumpConstraint(fout, (const ConstraintInfo *) dobj);
   11435         472 :             break;
   11436         180 :         case DO_PROCLANG:
   11437         180 :             dumpProcLang(fout, (const ProcLangInfo *) dobj);
   11438         180 :             break;
   11439         178 :         case DO_CAST:
   11440         178 :             dumpCast(fout, (const CastInfo *) dobj);
   11441         178 :             break;
   11442          98 :         case DO_TRANSFORM:
   11443          98 :             dumpTransform(fout, (const TransformInfo *) dobj);
   11444          98 :             break;
   11445        1136 :         case DO_SEQUENCE_SET:
   11446        1136 :             dumpSequenceData(fout, (const TableDataInfo *) dobj);
   11447        1136 :             break;
   11448       12006 :         case DO_TABLE_DATA:
   11449       12006 :             dumpTableData(fout, (const TableDataInfo *) dobj);
   11450       12006 :             break;
   11451       37788 :         case DO_DUMMY_TYPE:
   11452             :             /* table rowtypes and array types are never dumped separately */
   11453       37788 :             break;
   11454          90 :         case DO_TSPARSER:
   11455          90 :             dumpTSParser(fout, (const TSParserInfo *) dobj);
   11456          90 :             break;
   11457         408 :         case DO_TSDICT:
   11458         408 :             dumpTSDictionary(fout, (const TSDictInfo *) dobj);
   11459         408 :             break;
   11460         114 :         case DO_TSTEMPLATE:
   11461         114 :             dumpTSTemplate(fout, (const TSTemplateInfo *) dobj);
   11462         114 :             break;
   11463         328 :         case DO_TSCONFIG:
   11464         328 :             dumpTSConfig(fout, (const TSConfigInfo *) dobj);
   11465         328 :             break;
   11466         118 :         case DO_FDW:
   11467         118 :             dumpForeignDataWrapper(fout, (const FdwInfo *) dobj);
   11468         118 :             break;
   11469         126 :         case DO_FOREIGN_SERVER:
   11470         126 :             dumpForeignServer(fout, (const ForeignServerInfo *) dobj);
   11471         126 :             break;
   11472         332 :         case DO_DEFAULT_ACL:
   11473         332 :             dumpDefaultACL(fout, (const DefaultACLInfo *) dobj);
   11474         332 :             break;
   11475         164 :         case DO_LARGE_OBJECT:
   11476         164 :             dumpLO(fout, (const LoInfo *) dobj);
   11477         164 :             break;
   11478         164 :         case DO_LARGE_OBJECT_DATA:
   11479         164 :             if (dobj->dump & DUMP_COMPONENT_DATA)
   11480             :             {
   11481             :                 LoInfo     *loinfo;
   11482             :                 TocEntry   *te;
   11483             : 
   11484         164 :                 loinfo = (LoInfo *) findObjectByDumpId(dobj->dependencies[0]);
   11485         164 :                 if (loinfo == NULL)
   11486           0 :                     pg_fatal("missing metadata for large objects \"%s\"",
   11487             :                              dobj->name);
   11488             : 
   11489         164 :                 te = ArchiveEntry(fout, dobj->catId, dobj->dumpId,
   11490         164 :                                   ARCHIVE_OPTS(.tag = dobj->name,
   11491             :                                                .owner = loinfo->rolname,
   11492             :                                                .description = "BLOBS",
   11493             :                                                .section = SECTION_DATA,
   11494             :                                                .deps = dobj->dependencies,
   11495             :                                                .nDeps = dobj->nDeps,
   11496             :                                                .dumpFn = dumpLOs,
   11497             :                                                .dumpArg = loinfo));
   11498             : 
   11499             :                 /*
   11500             :                  * Set the TocEntry's dataLength in case we are doing a
   11501             :                  * parallel dump and want to order dump jobs by table size.
   11502             :                  * (We need some size estimate for every TocEntry with a
   11503             :                  * DataDumper function.)  We don't currently have any cheap
   11504             :                  * way to estimate the size of LOs, but fortunately it doesn't
   11505             :                  * matter too much as long as we get large batches of LOs
   11506             :                  * processed reasonably early.  Assume 8K per blob.
   11507             :                  */
   11508         164 :                 te->dataLength = loinfo->numlos * (pgoff_t) 8192;
   11509             :             }
   11510         164 :             break;
   11511         780 :         case DO_POLICY:
   11512         780 :             dumpPolicy(fout, (const PolicyInfo *) dobj);
   11513         780 :             break;
   11514         412 :         case DO_PUBLICATION:
   11515         412 :             dumpPublication(fout, (const PublicationInfo *) dobj);
   11516         412 :             break;
   11517         574 :         case DO_PUBLICATION_REL:
   11518         574 :             dumpPublicationTable(fout, (const PublicationRelInfo *) dobj);
   11519         574 :             break;
   11520         164 :         case DO_PUBLICATION_TABLE_IN_SCHEMA:
   11521         164 :             dumpPublicationNamespace(fout,
   11522             :                                      (const PublicationSchemaInfo *) dobj);
   11523         164 :             break;
   11524         250 :         case DO_SUBSCRIPTION:
   11525         250 :             dumpSubscription(fout, (const SubscriptionInfo *) dobj);
   11526         250 :             break;
   11527           4 :         case DO_SUBSCRIPTION_REL:
   11528           4 :             dumpSubscriptionTable(fout, (const SubRelInfo *) dobj);
   11529           4 :             break;
   11530       18518 :         case DO_REL_STATS:
   11531       18518 :             dumpRelationStats(fout, (const RelStatsInfo *) dobj);
   11532       18518 :             break;
   11533         936 :         case DO_PRE_DATA_BOUNDARY:
   11534             :         case DO_POST_DATA_BOUNDARY:
   11535             :             /* never dumped, nothing to do */
   11536         936 :             break;
   11537             :     }
   11538             : }
   11539             : 
   11540             : /*
   11541             :  * dumpNamespace
   11542             :  *    writes out to fout the queries to recreate a user-defined namespace
   11543             :  */
   11544             : static void
   11545        1218 : dumpNamespace(Archive *fout, const NamespaceInfo *nspinfo)
   11546             : {
   11547        1218 :     DumpOptions *dopt = fout->dopt;
   11548             :     PQExpBuffer q;
   11549             :     PQExpBuffer delq;
   11550             :     char       *qnspname;
   11551             : 
   11552             :     /* Do nothing if not dumping schema */
   11553        1218 :     if (!dopt->dumpSchema)
   11554          56 :         return;
   11555             : 
   11556        1162 :     q = createPQExpBuffer();
   11557        1162 :     delq = createPQExpBuffer();
   11558             : 
   11559        1162 :     qnspname = pg_strdup(fmtId(nspinfo->dobj.name));
   11560             : 
   11561        1162 :     if (nspinfo->create)
   11562             :     {
   11563         764 :         appendPQExpBuffer(delq, "DROP SCHEMA %s;\n", qnspname);
   11564         764 :         appendPQExpBuffer(q, "CREATE SCHEMA %s;\n", qnspname);
   11565             :     }
   11566             :     else
   11567             :     {
   11568             :         /* see selectDumpableNamespace() */
   11569         398 :         appendPQExpBufferStr(delq,
   11570             :                              "-- *not* dropping schema, since initdb creates it\n");
   11571         398 :         appendPQExpBufferStr(q,
   11572             :                              "-- *not* creating schema, since initdb creates it\n");
   11573             :     }
   11574             : 
   11575        1162 :     if (dopt->binary_upgrade)
   11576         152 :         binary_upgrade_extension_member(q, &nspinfo->dobj,
   11577             :                                         "SCHEMA", qnspname, NULL);
   11578             : 
   11579        1162 :     if (nspinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   11580         434 :         ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
   11581         434 :                      ARCHIVE_OPTS(.tag = nspinfo->dobj.name,
   11582             :                                   .owner = nspinfo->rolname,
   11583             :                                   .description = "SCHEMA",
   11584             :                                   .section = SECTION_PRE_DATA,
   11585             :                                   .createStmt = q->data,
   11586             :                                   .dropStmt = delq->data));
   11587             : 
   11588             :     /* Dump Schema Comments and Security Labels */
   11589        1162 :     if (nspinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   11590             :     {
   11591         408 :         const char *initdb_comment = NULL;
   11592             : 
   11593         408 :         if (!nspinfo->create && strcmp(qnspname, "public") == 0)
   11594         340 :             initdb_comment = "standard public schema";
   11595         408 :         dumpCommentExtended(fout, "SCHEMA", qnspname,
   11596             :                             NULL, nspinfo->rolname,
   11597             :                             nspinfo->dobj.catId, 0, nspinfo->dobj.dumpId,
   11598             :                             initdb_comment);
   11599             :     }
   11600             : 
   11601        1162 :     if (nspinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   11602           0 :         dumpSecLabel(fout, "SCHEMA", qnspname,
   11603             :                      NULL, nspinfo->rolname,
   11604             :                      nspinfo->dobj.catId, 0, nspinfo->dobj.dumpId);
   11605             : 
   11606        1162 :     if (nspinfo->dobj.dump & DUMP_COMPONENT_ACL)
   11607         936 :         dumpACL(fout, nspinfo->dobj.dumpId, InvalidDumpId, "SCHEMA",
   11608             :                 qnspname, NULL, NULL,
   11609             :                 NULL, nspinfo->rolname, &nspinfo->dacl);
   11610             : 
   11611        1162 :     free(qnspname);
   11612             : 
   11613        1162 :     destroyPQExpBuffer(q);
   11614        1162 :     destroyPQExpBuffer(delq);
   11615             : }
   11616             : 
   11617             : /*
   11618             :  * dumpExtension
   11619             :  *    writes out to fout the queries to recreate an extension
   11620             :  */
   11621             : static void
   11622          38 : dumpExtension(Archive *fout, const ExtensionInfo *extinfo)
   11623             : {
   11624          38 :     DumpOptions *dopt = fout->dopt;
   11625             :     PQExpBuffer q;
   11626             :     PQExpBuffer delq;
   11627             :     char       *qextname;
   11628             : 
   11629             :     /* Do nothing if not dumping schema */
   11630          38 :     if (!dopt->dumpSchema)
   11631           2 :         return;
   11632             : 
   11633          36 :     q = createPQExpBuffer();
   11634          36 :     delq = createPQExpBuffer();
   11635             : 
   11636          36 :     qextname = pg_strdup(fmtId(extinfo->dobj.name));
   11637             : 
   11638          36 :     appendPQExpBuffer(delq, "DROP EXTENSION %s;\n", qextname);
   11639             : 
   11640          36 :     if (!dopt->binary_upgrade)
   11641             :     {
   11642             :         /*
   11643             :          * In a regular dump, we simply create the extension, intentionally
   11644             :          * not specifying a version, so that the destination installation's
   11645             :          * default version is used.
   11646             :          *
   11647             :          * Use of IF NOT EXISTS here is unlike our behavior for other object
   11648             :          * types; but there are various scenarios in which it's convenient to
   11649             :          * manually create the desired extension before restoring, so we
   11650             :          * prefer to allow it to exist already.
   11651             :          */
   11652          34 :         appendPQExpBuffer(q, "CREATE EXTENSION IF NOT EXISTS %s WITH SCHEMA %s;\n",
   11653          34 :                           qextname, fmtId(extinfo->namespace));
   11654             :     }
   11655             :     else
   11656             :     {
   11657             :         /*
   11658             :          * In binary-upgrade mode, it's critical to reproduce the state of the
   11659             :          * database exactly, so our procedure is to create an empty extension,
   11660             :          * restore all the contained objects normally, and add them to the
   11661             :          * extension one by one.  This function performs just the first of
   11662             :          * those steps.  binary_upgrade_extension_member() takes care of
   11663             :          * adding member objects as they're created.
   11664             :          */
   11665             :         int         i;
   11666             :         int         n;
   11667             : 
   11668           2 :         appendPQExpBufferStr(q, "-- For binary upgrade, create an empty extension and insert objects into it\n");
   11669             : 
   11670             :         /*
   11671             :          * We unconditionally create the extension, so we must drop it if it
   11672             :          * exists.  This could happen if the user deleted 'plpgsql' and then
   11673             :          * readded it, causing its oid to be greater than g_last_builtin_oid.
   11674             :          */
   11675           2 :         appendPQExpBuffer(q, "DROP EXTENSION IF EXISTS %s;\n", qextname);
   11676             : 
   11677           2 :         appendPQExpBufferStr(q,
   11678             :                              "SELECT pg_catalog.binary_upgrade_create_empty_extension(");
   11679           2 :         appendStringLiteralAH(q, extinfo->dobj.name, fout);
   11680           2 :         appendPQExpBufferStr(q, ", ");
   11681           2 :         appendStringLiteralAH(q, extinfo->namespace, fout);
   11682           2 :         appendPQExpBufferStr(q, ", ");
   11683           2 :         appendPQExpBuffer(q, "%s, ", extinfo->relocatable ? "true" : "false");
   11684           2 :         appendStringLiteralAH(q, extinfo->extversion, fout);
   11685           2 :         appendPQExpBufferStr(q, ", ");
   11686             : 
   11687             :         /*
   11688             :          * Note that we're pushing extconfig (an OID array) back into
   11689             :          * pg_extension exactly as-is.  This is OK because pg_class OIDs are
   11690             :          * preserved in binary upgrade.
   11691             :          */
   11692           2 :         if (strlen(extinfo->extconfig) > 2)
   11693           2 :             appendStringLiteralAH(q, extinfo->extconfig, fout);
   11694             :         else
   11695           0 :             appendPQExpBufferStr(q, "NULL");
   11696           2 :         appendPQExpBufferStr(q, ", ");
   11697           2 :         if (strlen(extinfo->extcondition) > 2)
   11698           2 :             appendStringLiteralAH(q, extinfo->extcondition, fout);
   11699             :         else
   11700           0 :             appendPQExpBufferStr(q, "NULL");
   11701           2 :         appendPQExpBufferStr(q, ", ");
   11702           2 :         appendPQExpBufferStr(q, "ARRAY[");
   11703           2 :         n = 0;
   11704           4 :         for (i = 0; i < extinfo->dobj.nDeps; i++)
   11705             :         {
   11706             :             DumpableObject *extobj;
   11707             : 
   11708           2 :             extobj = findObjectByDumpId(extinfo->dobj.dependencies[i]);
   11709           2 :             if (extobj && extobj->objType == DO_EXTENSION)
   11710             :             {
   11711           0 :                 if (n++ > 0)
   11712           0 :                     appendPQExpBufferChar(q, ',');
   11713           0 :                 appendStringLiteralAH(q, extobj->name, fout);
   11714             :             }
   11715             :         }
   11716           2 :         appendPQExpBufferStr(q, "]::pg_catalog.text[]");
   11717           2 :         appendPQExpBufferStr(q, ");\n");
   11718             :     }
   11719             : 
   11720          36 :     if (extinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   11721          36 :         ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
   11722          36 :                      ARCHIVE_OPTS(.tag = extinfo->dobj.name,
   11723             :                                   .description = "EXTENSION",
   11724             :                                   .section = SECTION_PRE_DATA,
   11725             :                                   .createStmt = q->data,
   11726             :                                   .dropStmt = delq->data));
   11727             : 
   11728             :     /* Dump Extension Comments and Security Labels */
   11729          36 :     if (extinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   11730          36 :         dumpComment(fout, "EXTENSION", qextname,
   11731             :                     NULL, "",
   11732             :                     extinfo->dobj.catId, 0, extinfo->dobj.dumpId);
   11733             : 
   11734          36 :     if (extinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   11735           0 :         dumpSecLabel(fout, "EXTENSION", qextname,
   11736             :                      NULL, "",
   11737             :                      extinfo->dobj.catId, 0, extinfo->dobj.dumpId);
   11738             : 
   11739          36 :     free(qextname);
   11740             : 
   11741          36 :     destroyPQExpBuffer(q);
   11742          36 :     destroyPQExpBuffer(delq);
   11743             : }
   11744             : 
   11745             : /*
   11746             :  * dumpType
   11747             :  *    writes out to fout the queries to recreate a user-defined type
   11748             :  */
   11749             : static void
   11750        2148 : dumpType(Archive *fout, const TypeInfo *tyinfo)
   11751             : {
   11752        2148 :     DumpOptions *dopt = fout->dopt;
   11753             : 
   11754             :     /* Do nothing if not dumping schema */
   11755        2148 :     if (!dopt->dumpSchema)
   11756          86 :         return;
   11757             : 
   11758             :     /* Dump out in proper style */
   11759        2062 :     if (tyinfo->typtype == TYPTYPE_BASE)
   11760         604 :         dumpBaseType(fout, tyinfo);
   11761        1458 :     else if (tyinfo->typtype == TYPTYPE_DOMAIN)
   11762         440 :         dumpDomain(fout, tyinfo);
   11763        1018 :     else if (tyinfo->typtype == TYPTYPE_COMPOSITE)
   11764         364 :         dumpCompositeType(fout, tyinfo);
   11765         654 :     else if (tyinfo->typtype == TYPTYPE_ENUM)
   11766         140 :         dumpEnumType(fout, tyinfo);
   11767         514 :     else if (tyinfo->typtype == TYPTYPE_RANGE)
   11768         276 :         dumpRangeType(fout, tyinfo);
   11769         238 :     else if (tyinfo->typtype == TYPTYPE_PSEUDO && !tyinfo->isDefined)
   11770          88 :         dumpUndefinedType(fout, tyinfo);
   11771             :     else
   11772         150 :         pg_log_warning("typtype of data type \"%s\" appears to be invalid",
   11773             :                        tyinfo->dobj.name);
   11774             : }
   11775             : 
   11776             : /*
   11777             :  * dumpEnumType
   11778             :  *    writes out to fout the queries to recreate a user-defined enum type
   11779             :  */
   11780             : static void
   11781         140 : dumpEnumType(Archive *fout, const TypeInfo *tyinfo)
   11782             : {
   11783         140 :     DumpOptions *dopt = fout->dopt;
   11784         140 :     PQExpBuffer q = createPQExpBuffer();
   11785         140 :     PQExpBuffer delq = createPQExpBuffer();
   11786         140 :     PQExpBuffer query = createPQExpBuffer();
   11787             :     PGresult   *res;
   11788             :     int         num,
   11789             :                 i;
   11790             :     Oid         enum_oid;
   11791             :     char       *qtypname;
   11792             :     char       *qualtypname;
   11793             :     char       *label;
   11794             :     int         i_enumlabel;
   11795             :     int         i_oid;
   11796             : 
   11797         140 :     if (!fout->is_prepared[PREPQUERY_DUMPENUMTYPE])
   11798             :     {
   11799             :         /* Set up query for enum-specific details */
   11800          92 :         appendPQExpBufferStr(query,
   11801             :                              "PREPARE dumpEnumType(pg_catalog.oid) AS\n"
   11802             :                              "SELECT oid, enumlabel "
   11803             :                              "FROM pg_catalog.pg_enum "
   11804             :                              "WHERE enumtypid = $1 "
   11805             :                              "ORDER BY enumsortorder");
   11806             : 
   11807          92 :         ExecuteSqlStatement(fout, query->data);
   11808             : 
   11809          92 :         fout->is_prepared[PREPQUERY_DUMPENUMTYPE] = true;
   11810             :     }
   11811             : 
   11812         140 :     printfPQExpBuffer(query,
   11813             :                       "EXECUTE dumpEnumType('%u')",
   11814             :                       tyinfo->dobj.catId.oid);
   11815             : 
   11816         140 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   11817             : 
   11818         140 :     num = PQntuples(res);
   11819             : 
   11820         140 :     qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
   11821         140 :     qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
   11822             : 
   11823             :     /*
   11824             :      * CASCADE shouldn't be required here as for normal types since the I/O
   11825             :      * functions are generic and do not get dropped.
   11826             :      */
   11827         140 :     appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
   11828             : 
   11829         140 :     if (dopt->binary_upgrade)
   11830          10 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   11831             :                                                  tyinfo->dobj.catId.oid,
   11832             :                                                  false, false);
   11833             : 
   11834         140 :     appendPQExpBuffer(q, "CREATE TYPE %s AS ENUM (",
   11835             :                       qualtypname);
   11836             : 
   11837         140 :     if (!dopt->binary_upgrade)
   11838             :     {
   11839         130 :         i_enumlabel = PQfnumber(res, "enumlabel");
   11840             : 
   11841             :         /* Labels with server-assigned oids */
   11842        1080 :         for (i = 0; i < num; i++)
   11843             :         {
   11844         950 :             label = PQgetvalue(res, i, i_enumlabel);
   11845         950 :             if (i > 0)
   11846         820 :                 appendPQExpBufferChar(q, ',');
   11847         950 :             appendPQExpBufferStr(q, "\n    ");
   11848         950 :             appendStringLiteralAH(q, label, fout);
   11849             :         }
   11850             :     }
   11851             : 
   11852         140 :     appendPQExpBufferStr(q, "\n);\n");
   11853             : 
   11854         140 :     if (dopt->binary_upgrade)
   11855             :     {
   11856          10 :         i_oid = PQfnumber(res, "oid");
   11857          10 :         i_enumlabel = PQfnumber(res, "enumlabel");
   11858             : 
   11859             :         /* Labels with dump-assigned (preserved) oids */
   11860         116 :         for (i = 0; i < num; i++)
   11861             :         {
   11862         106 :             enum_oid = atooid(PQgetvalue(res, i, i_oid));
   11863         106 :             label = PQgetvalue(res, i, i_enumlabel);
   11864             : 
   11865         106 :             if (i == 0)
   11866          10 :                 appendPQExpBufferStr(q, "\n-- For binary upgrade, must preserve pg_enum oids\n");
   11867         106 :             appendPQExpBuffer(q,
   11868             :                               "SELECT pg_catalog.binary_upgrade_set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
   11869             :                               enum_oid);
   11870         106 :             appendPQExpBuffer(q, "ALTER TYPE %s ADD VALUE ", qualtypname);
   11871         106 :             appendStringLiteralAH(q, label, fout);
   11872         106 :             appendPQExpBufferStr(q, ";\n\n");
   11873             :         }
   11874             :     }
   11875             : 
   11876         140 :     if (dopt->binary_upgrade)
   11877          10 :         binary_upgrade_extension_member(q, &tyinfo->dobj,
   11878             :                                         "TYPE", qtypname,
   11879          10 :                                         tyinfo->dobj.namespace->dobj.name);
   11880             : 
   11881         140 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   11882         140 :         ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
   11883         140 :                      ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
   11884             :                                   .namespace = tyinfo->dobj.namespace->dobj.name,
   11885             :                                   .owner = tyinfo->rolname,
   11886             :                                   .description = "TYPE",
   11887             :                                   .section = SECTION_PRE_DATA,
   11888             :                                   .createStmt = q->data,
   11889             :                                   .dropStmt = delq->data));
   11890             : 
   11891             :     /* Dump Type Comments and Security Labels */
   11892         140 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   11893          72 :         dumpComment(fout, "TYPE", qtypname,
   11894          72 :                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   11895             :                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   11896             : 
   11897         140 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   11898           0 :         dumpSecLabel(fout, "TYPE", qtypname,
   11899           0 :                      tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   11900             :                      tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   11901             : 
   11902         140 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
   11903          72 :         dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
   11904             :                 qtypname, NULL,
   11905          72 :                 tyinfo->dobj.namespace->dobj.name,
   11906             :                 NULL, tyinfo->rolname, &tyinfo->dacl);
   11907             : 
   11908         140 :     PQclear(res);
   11909         140 :     destroyPQExpBuffer(q);
   11910         140 :     destroyPQExpBuffer(delq);
   11911         140 :     destroyPQExpBuffer(query);
   11912         140 :     free(qtypname);
   11913         140 :     free(qualtypname);
   11914         140 : }
   11915             : 
   11916             : /*
   11917             :  * dumpRangeType
   11918             :  *    writes out to fout the queries to recreate a user-defined range type
   11919             :  */
   11920             : static void
   11921         276 : dumpRangeType(Archive *fout, const TypeInfo *tyinfo)
   11922             : {
   11923         276 :     DumpOptions *dopt = fout->dopt;
   11924         276 :     PQExpBuffer q = createPQExpBuffer();
   11925         276 :     PQExpBuffer delq = createPQExpBuffer();
   11926         276 :     PQExpBuffer query = createPQExpBuffer();
   11927             :     PGresult   *res;
   11928             :     Oid         collationOid;
   11929             :     char       *qtypname;
   11930             :     char       *qualtypname;
   11931             :     char       *procname;
   11932             : 
   11933         276 :     if (!fout->is_prepared[PREPQUERY_DUMPRANGETYPE])
   11934             :     {
   11935             :         /* Set up query for range-specific details */
   11936          94 :         appendPQExpBufferStr(query,
   11937             :                              "PREPARE dumpRangeType(pg_catalog.oid) AS\n");
   11938             : 
   11939          94 :         appendPQExpBufferStr(query,
   11940             :                              "SELECT ");
   11941             : 
   11942          94 :         if (fout->remoteVersion >= 140000)
   11943          94 :             appendPQExpBufferStr(query,
   11944             :                                  "pg_catalog.format_type(rngmultitypid, NULL) AS rngmultitype, ");
   11945             :         else
   11946           0 :             appendPQExpBufferStr(query,
   11947             :                                  "NULL AS rngmultitype, ");
   11948             : 
   11949          94 :         appendPQExpBufferStr(query,
   11950             :                              "pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
   11951             :                              "opc.opcname AS opcname, "
   11952             :                              "(SELECT nspname FROM pg_catalog.pg_namespace nsp "
   11953             :                              "  WHERE nsp.oid = opc.opcnamespace) AS opcnsp, "
   11954             :                              "opc.opcdefault, "
   11955             :                              "CASE WHEN rngcollation = st.typcollation THEN 0 "
   11956             :                              "     ELSE rngcollation END AS collation, "
   11957             :                              "rngcanonical, rngsubdiff "
   11958             :                              "FROM pg_catalog.pg_range r, pg_catalog.pg_type st, "
   11959             :                              "     pg_catalog.pg_opclass opc "
   11960             :                              "WHERE st.oid = rngsubtype AND opc.oid = rngsubopc AND "
   11961             :                              "rngtypid = $1");
   11962             : 
   11963          94 :         ExecuteSqlStatement(fout, query->data);
   11964             : 
   11965          94 :         fout->is_prepared[PREPQUERY_DUMPRANGETYPE] = true;
   11966             :     }
   11967             : 
   11968         276 :     printfPQExpBuffer(query,
   11969             :                       "EXECUTE dumpRangeType('%u')",
   11970             :                       tyinfo->dobj.catId.oid);
   11971             : 
   11972         276 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   11973             : 
   11974         276 :     qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
   11975         276 :     qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
   11976             : 
   11977             :     /*
   11978             :      * CASCADE shouldn't be required here as for normal types since the I/O
   11979             :      * functions are generic and do not get dropped.
   11980             :      */
   11981         276 :     appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
   11982             : 
   11983         276 :     if (dopt->binary_upgrade)
   11984          16 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   11985             :                                                  tyinfo->dobj.catId.oid,
   11986             :                                                  false, true);
   11987             : 
   11988         276 :     appendPQExpBuffer(q, "CREATE TYPE %s AS RANGE (",
   11989             :                       qualtypname);
   11990             : 
   11991         276 :     appendPQExpBuffer(q, "\n    subtype = %s",
   11992             :                       PQgetvalue(res, 0, PQfnumber(res, "rngsubtype")));
   11993             : 
   11994         276 :     if (!PQgetisnull(res, 0, PQfnumber(res, "rngmultitype")))
   11995         276 :         appendPQExpBuffer(q, ",\n    multirange_type_name = %s",
   11996             :                           PQgetvalue(res, 0, PQfnumber(res, "rngmultitype")));
   11997             : 
   11998             :     /* print subtype_opclass only if not default for subtype */
   11999         276 :     if (PQgetvalue(res, 0, PQfnumber(res, "opcdefault"))[0] != 't')
   12000             :     {
   12001          72 :         char       *opcname = PQgetvalue(res, 0, PQfnumber(res, "opcname"));
   12002          72 :         char       *nspname = PQgetvalue(res, 0, PQfnumber(res, "opcnsp"));
   12003             : 
   12004          72 :         appendPQExpBuffer(q, ",\n    subtype_opclass = %s.",
   12005             :                           fmtId(nspname));
   12006          72 :         appendPQExpBufferStr(q, fmtId(opcname));
   12007             :     }
   12008             : 
   12009         276 :     collationOid = atooid(PQgetvalue(res, 0, PQfnumber(res, "collation")));
   12010         276 :     if (OidIsValid(collationOid))
   12011             :     {
   12012          88 :         CollInfo   *coll = findCollationByOid(collationOid);
   12013             : 
   12014          88 :         if (coll)
   12015          88 :             appendPQExpBuffer(q, ",\n    collation = %s",
   12016          88 :                               fmtQualifiedDumpable(coll));
   12017             :     }
   12018             : 
   12019         276 :     procname = PQgetvalue(res, 0, PQfnumber(res, "rngcanonical"));
   12020         276 :     if (strcmp(procname, "-") != 0)
   12021          18 :         appendPQExpBuffer(q, ",\n    canonical = %s", procname);
   12022             : 
   12023         276 :     procname = PQgetvalue(res, 0, PQfnumber(res, "rngsubdiff"));
   12024         276 :     if (strcmp(procname, "-") != 0)
   12025          52 :         appendPQExpBuffer(q, ",\n    subtype_diff = %s", procname);
   12026             : 
   12027         276 :     appendPQExpBufferStr(q, "\n);\n");
   12028             : 
   12029         276 :     if (dopt->binary_upgrade)
   12030          16 :         binary_upgrade_extension_member(q, &tyinfo->dobj,
   12031             :                                         "TYPE", qtypname,
   12032          16 :                                         tyinfo->dobj.namespace->dobj.name);
   12033             : 
   12034         276 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12035         276 :         ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
   12036         276 :                      ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
   12037             :                                   .namespace = tyinfo->dobj.namespace->dobj.name,
   12038             :                                   .owner = tyinfo->rolname,
   12039             :                                   .description = "TYPE",
   12040             :                                   .section = SECTION_PRE_DATA,
   12041             :                                   .createStmt = q->data,
   12042             :                                   .dropStmt = delq->data));
   12043             : 
   12044             :     /* Dump Type Comments and Security Labels */
   12045         276 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   12046         108 :         dumpComment(fout, "TYPE", qtypname,
   12047         108 :                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12048             :                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12049             : 
   12050         276 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   12051           0 :         dumpSecLabel(fout, "TYPE", qtypname,
   12052           0 :                      tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12053             :                      tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12054             : 
   12055         276 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
   12056          72 :         dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
   12057             :                 qtypname, NULL,
   12058          72 :                 tyinfo->dobj.namespace->dobj.name,
   12059             :                 NULL, tyinfo->rolname, &tyinfo->dacl);
   12060             : 
   12061         276 :     PQclear(res);
   12062         276 :     destroyPQExpBuffer(q);
   12063         276 :     destroyPQExpBuffer(delq);
   12064         276 :     destroyPQExpBuffer(query);
   12065         276 :     free(qtypname);
   12066         276 :     free(qualtypname);
   12067         276 : }
   12068             : 
   12069             : /*
   12070             :  * dumpUndefinedType
   12071             :  *    writes out to fout the queries to recreate a !typisdefined type
   12072             :  *
   12073             :  * This is a shell type, but we use different terminology to distinguish
   12074             :  * this case from where we have to emit a shell type definition to break
   12075             :  * circular dependencies.  An undefined type shouldn't ever have anything
   12076             :  * depending on it.
   12077             :  */
   12078             : static void
   12079          88 : dumpUndefinedType(Archive *fout, const TypeInfo *tyinfo)
   12080             : {
   12081          88 :     DumpOptions *dopt = fout->dopt;
   12082          88 :     PQExpBuffer q = createPQExpBuffer();
   12083          88 :     PQExpBuffer delq = createPQExpBuffer();
   12084             :     char       *qtypname;
   12085             :     char       *qualtypname;
   12086             : 
   12087          88 :     qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
   12088          88 :     qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
   12089             : 
   12090          88 :     appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
   12091             : 
   12092          88 :     if (dopt->binary_upgrade)
   12093           4 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   12094             :                                                  tyinfo->dobj.catId.oid,
   12095             :                                                  false, false);
   12096             : 
   12097          88 :     appendPQExpBuffer(q, "CREATE TYPE %s;\n",
   12098             :                       qualtypname);
   12099             : 
   12100          88 :     if (dopt->binary_upgrade)
   12101           4 :         binary_upgrade_extension_member(q, &tyinfo->dobj,
   12102             :                                         "TYPE", qtypname,
   12103           4 :                                         tyinfo->dobj.namespace->dobj.name);
   12104             : 
   12105          88 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12106          88 :         ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
   12107          88 :                      ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
   12108             :                                   .namespace = tyinfo->dobj.namespace->dobj.name,
   12109             :                                   .owner = tyinfo->rolname,
   12110             :                                   .description = "TYPE",
   12111             :                                   .section = SECTION_PRE_DATA,
   12112             :                                   .createStmt = q->data,
   12113             :                                   .dropStmt = delq->data));
   12114             : 
   12115             :     /* Dump Type Comments and Security Labels */
   12116          88 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   12117          72 :         dumpComment(fout, "TYPE", qtypname,
   12118          72 :                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12119             :                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12120             : 
   12121          88 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   12122           0 :         dumpSecLabel(fout, "TYPE", qtypname,
   12123           0 :                      tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12124             :                      tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12125             : 
   12126          88 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
   12127           0 :         dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
   12128             :                 qtypname, NULL,
   12129           0 :                 tyinfo->dobj.namespace->dobj.name,
   12130             :                 NULL, tyinfo->rolname, &tyinfo->dacl);
   12131             : 
   12132          88 :     destroyPQExpBuffer(q);
   12133          88 :     destroyPQExpBuffer(delq);
   12134          88 :     free(qtypname);
   12135          88 :     free(qualtypname);
   12136          88 : }
   12137             : 
   12138             : /*
   12139             :  * dumpBaseType
   12140             :  *    writes out to fout the queries to recreate a user-defined base type
   12141             :  */
   12142             : static void
   12143         604 : dumpBaseType(Archive *fout, const TypeInfo *tyinfo)
   12144             : {
   12145         604 :     DumpOptions *dopt = fout->dopt;
   12146         604 :     PQExpBuffer q = createPQExpBuffer();
   12147         604 :     PQExpBuffer delq = createPQExpBuffer();
   12148         604 :     PQExpBuffer query = createPQExpBuffer();
   12149             :     PGresult   *res;
   12150             :     char       *qtypname;
   12151             :     char       *qualtypname;
   12152             :     char       *typlen;
   12153             :     char       *typinput;
   12154             :     char       *typoutput;
   12155             :     char       *typreceive;
   12156             :     char       *typsend;
   12157             :     char       *typmodin;
   12158             :     char       *typmodout;
   12159             :     char       *typanalyze;
   12160             :     char       *typsubscript;
   12161             :     Oid         typreceiveoid;
   12162             :     Oid         typsendoid;
   12163             :     Oid         typmodinoid;
   12164             :     Oid         typmodoutoid;
   12165             :     Oid         typanalyzeoid;
   12166             :     Oid         typsubscriptoid;
   12167             :     char       *typcategory;
   12168             :     char       *typispreferred;
   12169             :     char       *typdelim;
   12170             :     char       *typbyval;
   12171             :     char       *typalign;
   12172             :     char       *typstorage;
   12173             :     char       *typcollatable;
   12174             :     char       *typdefault;
   12175         604 :     bool        typdefault_is_literal = false;
   12176             : 
   12177         604 :     if (!fout->is_prepared[PREPQUERY_DUMPBASETYPE])
   12178             :     {
   12179             :         /* Set up query for type-specific details */
   12180          94 :         appendPQExpBufferStr(query,
   12181             :                              "PREPARE dumpBaseType(pg_catalog.oid) AS\n"
   12182             :                              "SELECT typlen, "
   12183             :                              "typinput, typoutput, typreceive, typsend, "
   12184             :                              "typreceive::pg_catalog.oid AS typreceiveoid, "
   12185             :                              "typsend::pg_catalog.oid AS typsendoid, "
   12186             :                              "typanalyze, "
   12187             :                              "typanalyze::pg_catalog.oid AS typanalyzeoid, "
   12188             :                              "typdelim, typbyval, typalign, typstorage, "
   12189             :                              "typmodin, typmodout, "
   12190             :                              "typmodin::pg_catalog.oid AS typmodinoid, "
   12191             :                              "typmodout::pg_catalog.oid AS typmodoutoid, "
   12192             :                              "typcategory, typispreferred, "
   12193             :                              "(typcollation <> 0) AS typcollatable, "
   12194             :                              "pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault, ");
   12195             : 
   12196          94 :         if (fout->remoteVersion >= 140000)
   12197          94 :             appendPQExpBufferStr(query,
   12198             :                                  "typsubscript, "
   12199             :                                  "typsubscript::pg_catalog.oid AS typsubscriptoid ");
   12200             :         else
   12201           0 :             appendPQExpBufferStr(query,
   12202             :                                  "'-' AS typsubscript, 0 AS typsubscriptoid ");
   12203             : 
   12204          94 :         appendPQExpBufferStr(query, "FROM pg_catalog.pg_type "
   12205             :                              "WHERE oid = $1");
   12206             : 
   12207          94 :         ExecuteSqlStatement(fout, query->data);
   12208             : 
   12209          94 :         fout->is_prepared[PREPQUERY_DUMPBASETYPE] = true;
   12210             :     }
   12211             : 
   12212         604 :     printfPQExpBuffer(query,
   12213             :                       "EXECUTE dumpBaseType('%u')",
   12214             :                       tyinfo->dobj.catId.oid);
   12215             : 
   12216         604 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   12217             : 
   12218         604 :     typlen = PQgetvalue(res, 0, PQfnumber(res, "typlen"));
   12219         604 :     typinput = PQgetvalue(res, 0, PQfnumber(res, "typinput"));
   12220         604 :     typoutput = PQgetvalue(res, 0, PQfnumber(res, "typoutput"));
   12221         604 :     typreceive = PQgetvalue(res, 0, PQfnumber(res, "typreceive"));
   12222         604 :     typsend = PQgetvalue(res, 0, PQfnumber(res, "typsend"));
   12223         604 :     typmodin = PQgetvalue(res, 0, PQfnumber(res, "typmodin"));
   12224         604 :     typmodout = PQgetvalue(res, 0, PQfnumber(res, "typmodout"));
   12225         604 :     typanalyze = PQgetvalue(res, 0, PQfnumber(res, "typanalyze"));
   12226         604 :     typsubscript = PQgetvalue(res, 0, PQfnumber(res, "typsubscript"));
   12227         604 :     typreceiveoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typreceiveoid")));
   12228         604 :     typsendoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typsendoid")));
   12229         604 :     typmodinoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typmodinoid")));
   12230         604 :     typmodoutoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typmodoutoid")));
   12231         604 :     typanalyzeoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typanalyzeoid")));
   12232         604 :     typsubscriptoid = atooid(PQgetvalue(res, 0, PQfnumber(res, "typsubscriptoid")));
   12233         604 :     typcategory = PQgetvalue(res, 0, PQfnumber(res, "typcategory"));
   12234         604 :     typispreferred = PQgetvalue(res, 0, PQfnumber(res, "typispreferred"));
   12235         604 :     typdelim = PQgetvalue(res, 0, PQfnumber(res, "typdelim"));
   12236         604 :     typbyval = PQgetvalue(res, 0, PQfnumber(res, "typbyval"));
   12237         604 :     typalign = PQgetvalue(res, 0, PQfnumber(res, "typalign"));
   12238         604 :     typstorage = PQgetvalue(res, 0, PQfnumber(res, "typstorage"));
   12239         604 :     typcollatable = PQgetvalue(res, 0, PQfnumber(res, "typcollatable"));
   12240         604 :     if (!PQgetisnull(res, 0, PQfnumber(res, "typdefaultbin")))
   12241           0 :         typdefault = PQgetvalue(res, 0, PQfnumber(res, "typdefaultbin"));
   12242         604 :     else if (!PQgetisnull(res, 0, PQfnumber(res, "typdefault")))
   12243             :     {
   12244         104 :         typdefault = PQgetvalue(res, 0, PQfnumber(res, "typdefault"));
   12245         104 :         typdefault_is_literal = true;   /* it needs quotes */
   12246             :     }
   12247             :     else
   12248         500 :         typdefault = NULL;
   12249             : 
   12250         604 :     qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
   12251         604 :     qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
   12252             : 
   12253             :     /*
   12254             :      * The reason we include CASCADE is that the circular dependency between
   12255             :      * the type and its I/O functions makes it impossible to drop the type any
   12256             :      * other way.
   12257             :      */
   12258         604 :     appendPQExpBuffer(delq, "DROP TYPE %s CASCADE;\n", qualtypname);
   12259             : 
   12260             :     /*
   12261             :      * We might already have a shell type, but setting pg_type_oid is
   12262             :      * harmless, and in any case we'd better set the array type OID.
   12263             :      */
   12264         604 :     if (dopt->binary_upgrade)
   12265          16 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   12266             :                                                  tyinfo->dobj.catId.oid,
   12267             :                                                  false, false);
   12268             : 
   12269         604 :     appendPQExpBuffer(q,
   12270             :                       "CREATE TYPE %s (\n"
   12271             :                       "    INTERNALLENGTH = %s",
   12272             :                       qualtypname,
   12273         604 :                       (strcmp(typlen, "-1") == 0) ? "variable" : typlen);
   12274             : 
   12275             :     /* regproc result is sufficiently quoted already */
   12276         604 :     appendPQExpBuffer(q, ",\n    INPUT = %s", typinput);
   12277         604 :     appendPQExpBuffer(q, ",\n    OUTPUT = %s", typoutput);
   12278         604 :     if (OidIsValid(typreceiveoid))
   12279         408 :         appendPQExpBuffer(q, ",\n    RECEIVE = %s", typreceive);
   12280         604 :     if (OidIsValid(typsendoid))
   12281         408 :         appendPQExpBuffer(q, ",\n    SEND = %s", typsend);
   12282         604 :     if (OidIsValid(typmodinoid))
   12283          76 :         appendPQExpBuffer(q, ",\n    TYPMOD_IN = %s", typmodin);
   12284         604 :     if (OidIsValid(typmodoutoid))
   12285          76 :         appendPQExpBuffer(q, ",\n    TYPMOD_OUT = %s", typmodout);
   12286         604 :     if (OidIsValid(typanalyzeoid))
   12287           6 :         appendPQExpBuffer(q, ",\n    ANALYZE = %s", typanalyze);
   12288             : 
   12289         604 :     if (strcmp(typcollatable, "t") == 0)
   12290          60 :         appendPQExpBufferStr(q, ",\n    COLLATABLE = true");
   12291             : 
   12292         604 :     if (typdefault != NULL)
   12293             :     {
   12294         104 :         appendPQExpBufferStr(q, ",\n    DEFAULT = ");
   12295         104 :         if (typdefault_is_literal)
   12296         104 :             appendStringLiteralAH(q, typdefault, fout);
   12297             :         else
   12298           0 :             appendPQExpBufferStr(q, typdefault);
   12299             :     }
   12300             : 
   12301         604 :     if (OidIsValid(typsubscriptoid))
   12302          64 :         appendPQExpBuffer(q, ",\n    SUBSCRIPT = %s", typsubscript);
   12303             : 
   12304         604 :     if (OidIsValid(tyinfo->typelem))
   12305          58 :         appendPQExpBuffer(q, ",\n    ELEMENT = %s",
   12306             :                           getFormattedTypeName(fout, tyinfo->typelem,
   12307             :                                                zeroIsError));
   12308             : 
   12309         604 :     if (strcmp(typcategory, "U") != 0)
   12310             :     {
   12311         316 :         appendPQExpBufferStr(q, ",\n    CATEGORY = ");
   12312         316 :         appendStringLiteralAH(q, typcategory, fout);
   12313             :     }
   12314             : 
   12315         604 :     if (strcmp(typispreferred, "t") == 0)
   12316          64 :         appendPQExpBufferStr(q, ",\n    PREFERRED = true");
   12317             : 
   12318         604 :     if (typdelim && strcmp(typdelim, ",") != 0)
   12319             :     {
   12320           6 :         appendPQExpBufferStr(q, ",\n    DELIMITER = ");
   12321           6 :         appendStringLiteralAH(q, typdelim, fout);
   12322             :     }
   12323             : 
   12324         604 :     if (*typalign == TYPALIGN_CHAR)
   12325          24 :         appendPQExpBufferStr(q, ",\n    ALIGNMENT = char");
   12326         580 :     else if (*typalign == TYPALIGN_SHORT)
   12327          12 :         appendPQExpBufferStr(q, ",\n    ALIGNMENT = int2");
   12328         568 :     else if (*typalign == TYPALIGN_INT)
   12329         400 :         appendPQExpBufferStr(q, ",\n    ALIGNMENT = int4");
   12330         168 :     else if (*typalign == TYPALIGN_DOUBLE)
   12331         168 :         appendPQExpBufferStr(q, ",\n    ALIGNMENT = double");
   12332             : 
   12333         604 :     if (*typstorage == TYPSTORAGE_PLAIN)
   12334         454 :         appendPQExpBufferStr(q, ",\n    STORAGE = plain");
   12335         150 :     else if (*typstorage == TYPSTORAGE_EXTERNAL)
   12336           0 :         appendPQExpBufferStr(q, ",\n    STORAGE = external");
   12337         150 :     else if (*typstorage == TYPSTORAGE_EXTENDED)
   12338         132 :         appendPQExpBufferStr(q, ",\n    STORAGE = extended");
   12339          18 :     else if (*typstorage == TYPSTORAGE_MAIN)
   12340          18 :         appendPQExpBufferStr(q, ",\n    STORAGE = main");
   12341             : 
   12342         604 :     if (strcmp(typbyval, "t") == 0)
   12343         288 :         appendPQExpBufferStr(q, ",\n    PASSEDBYVALUE");
   12344             : 
   12345         604 :     appendPQExpBufferStr(q, "\n);\n");
   12346             : 
   12347         604 :     if (dopt->binary_upgrade)
   12348          16 :         binary_upgrade_extension_member(q, &tyinfo->dobj,
   12349             :                                         "TYPE", qtypname,
   12350          16 :                                         tyinfo->dobj.namespace->dobj.name);
   12351             : 
   12352         604 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12353         604 :         ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
   12354         604 :                      ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
   12355             :                                   .namespace = tyinfo->dobj.namespace->dobj.name,
   12356             :                                   .owner = tyinfo->rolname,
   12357             :                                   .description = "TYPE",
   12358             :                                   .section = SECTION_PRE_DATA,
   12359             :                                   .createStmt = q->data,
   12360             :                                   .dropStmt = delq->data));
   12361             : 
   12362             :     /* Dump Type Comments and Security Labels */
   12363         604 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   12364         492 :         dumpComment(fout, "TYPE", qtypname,
   12365         492 :                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12366             :                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12367             : 
   12368         604 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   12369           0 :         dumpSecLabel(fout, "TYPE", qtypname,
   12370           0 :                      tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12371             :                      tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12372             : 
   12373         604 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
   12374          72 :         dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
   12375             :                 qtypname, NULL,
   12376          72 :                 tyinfo->dobj.namespace->dobj.name,
   12377             :                 NULL, tyinfo->rolname, &tyinfo->dacl);
   12378             : 
   12379         604 :     PQclear(res);
   12380         604 :     destroyPQExpBuffer(q);
   12381         604 :     destroyPQExpBuffer(delq);
   12382         604 :     destroyPQExpBuffer(query);
   12383         604 :     free(qtypname);
   12384         604 :     free(qualtypname);
   12385         604 : }
   12386             : 
   12387             : /*
   12388             :  * dumpDomain
   12389             :  *    writes out to fout the queries to recreate a user-defined domain
   12390             :  */
   12391             : static void
   12392         440 : dumpDomain(Archive *fout, const TypeInfo *tyinfo)
   12393             : {
   12394         440 :     DumpOptions *dopt = fout->dopt;
   12395         440 :     PQExpBuffer q = createPQExpBuffer();
   12396         440 :     PQExpBuffer delq = createPQExpBuffer();
   12397         440 :     PQExpBuffer query = createPQExpBuffer();
   12398             :     PGresult   *res;
   12399             :     int         i;
   12400             :     char       *qtypname;
   12401             :     char       *qualtypname;
   12402             :     char       *typnotnull;
   12403             :     char       *typdefn;
   12404             :     char       *typdefault;
   12405             :     Oid         typcollation;
   12406         440 :     bool        typdefault_is_literal = false;
   12407             : 
   12408         440 :     if (!fout->is_prepared[PREPQUERY_DUMPDOMAIN])
   12409             :     {
   12410             :         /* Set up query for domain-specific details */
   12411          88 :         appendPQExpBufferStr(query,
   12412             :                              "PREPARE dumpDomain(pg_catalog.oid) AS\n");
   12413             : 
   12414          88 :         appendPQExpBufferStr(query, "SELECT t.typnotnull, "
   12415             :                              "pg_catalog.format_type(t.typbasetype, t.typtypmod) AS typdefn, "
   12416             :                              "pg_catalog.pg_get_expr(t.typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, "
   12417             :                              "t.typdefault, "
   12418             :                              "CASE WHEN t.typcollation <> u.typcollation "
   12419             :                              "THEN t.typcollation ELSE 0 END AS typcollation "
   12420             :                              "FROM pg_catalog.pg_type t "
   12421             :                              "LEFT JOIN pg_catalog.pg_type u ON (t.typbasetype = u.oid) "
   12422             :                              "WHERE t.oid = $1");
   12423             : 
   12424          88 :         ExecuteSqlStatement(fout, query->data);
   12425             : 
   12426          88 :         fout->is_prepared[PREPQUERY_DUMPDOMAIN] = true;
   12427             :     }
   12428             : 
   12429         440 :     printfPQExpBuffer(query,
   12430             :                       "EXECUTE dumpDomain('%u')",
   12431             :                       tyinfo->dobj.catId.oid);
   12432             : 
   12433         440 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   12434             : 
   12435         440 :     typnotnull = PQgetvalue(res, 0, PQfnumber(res, "typnotnull"));
   12436         440 :     typdefn = PQgetvalue(res, 0, PQfnumber(res, "typdefn"));
   12437         440 :     if (!PQgetisnull(res, 0, PQfnumber(res, "typdefaultbin")))
   12438          88 :         typdefault = PQgetvalue(res, 0, PQfnumber(res, "typdefaultbin"));
   12439         352 :     else if (!PQgetisnull(res, 0, PQfnumber(res, "typdefault")))
   12440             :     {
   12441           0 :         typdefault = PQgetvalue(res, 0, PQfnumber(res, "typdefault"));
   12442           0 :         typdefault_is_literal = true;   /* it needs quotes */
   12443             :     }
   12444             :     else
   12445         352 :         typdefault = NULL;
   12446         440 :     typcollation = atooid(PQgetvalue(res, 0, PQfnumber(res, "typcollation")));
   12447             : 
   12448         440 :     if (dopt->binary_upgrade)
   12449          48 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   12450             :                                                  tyinfo->dobj.catId.oid,
   12451             :                                                  true,  /* force array type */
   12452             :                                                  false);    /* force multirange type */
   12453             : 
   12454         440 :     qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
   12455         440 :     qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
   12456             : 
   12457         440 :     appendPQExpBuffer(q,
   12458             :                       "CREATE DOMAIN %s AS %s",
   12459             :                       qualtypname,
   12460             :                       typdefn);
   12461             : 
   12462             :     /* Print collation only if different from base type's collation */
   12463         440 :     if (OidIsValid(typcollation))
   12464             :     {
   12465             :         CollInfo   *coll;
   12466             : 
   12467          72 :         coll = findCollationByOid(typcollation);
   12468          72 :         if (coll)
   12469          72 :             appendPQExpBuffer(q, " COLLATE %s", fmtQualifiedDumpable(coll));
   12470             :     }
   12471             : 
   12472         440 :     if (typnotnull[0] == 't')
   12473          48 :         appendPQExpBufferStr(q, " NOT NULL");
   12474             : 
   12475         440 :     if (typdefault != NULL)
   12476             :     {
   12477          88 :         appendPQExpBufferStr(q, " DEFAULT ");
   12478          88 :         if (typdefault_is_literal)
   12479           0 :             appendStringLiteralAH(q, typdefault, fout);
   12480             :         else
   12481          88 :             appendPQExpBufferStr(q, typdefault);
   12482             :     }
   12483             : 
   12484         440 :     PQclear(res);
   12485             : 
   12486             :     /*
   12487             :      * Add any CHECK constraints for the domain
   12488             :      */
   12489         736 :     for (i = 0; i < tyinfo->nDomChecks; i++)
   12490             :     {
   12491         296 :         ConstraintInfo *domcheck = &(tyinfo->domChecks[i]);
   12492             : 
   12493         296 :         if (!domcheck->separate)
   12494         296 :             appendPQExpBuffer(q, "\n\tCONSTRAINT %s %s",
   12495         296 :                               fmtId(domcheck->dobj.name), domcheck->condef);
   12496             :     }
   12497             : 
   12498         440 :     appendPQExpBufferStr(q, ";\n");
   12499             : 
   12500         440 :     appendPQExpBuffer(delq, "DROP DOMAIN %s;\n", qualtypname);
   12501             : 
   12502         440 :     if (dopt->binary_upgrade)
   12503          48 :         binary_upgrade_extension_member(q, &tyinfo->dobj,
   12504             :                                         "DOMAIN", qtypname,
   12505          48 :                                         tyinfo->dobj.namespace->dobj.name);
   12506             : 
   12507         440 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12508         440 :         ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
   12509         440 :                      ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
   12510             :                                   .namespace = tyinfo->dobj.namespace->dobj.name,
   12511             :                                   .owner = tyinfo->rolname,
   12512             :                                   .description = "DOMAIN",
   12513             :                                   .section = SECTION_PRE_DATA,
   12514             :                                   .createStmt = q->data,
   12515             :                                   .dropStmt = delq->data));
   12516             : 
   12517             :     /* Dump Domain Comments and Security Labels */
   12518         440 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   12519           0 :         dumpComment(fout, "DOMAIN", qtypname,
   12520           0 :                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12521             :                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12522             : 
   12523         440 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   12524           0 :         dumpSecLabel(fout, "DOMAIN", qtypname,
   12525           0 :                      tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12526             :                      tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12527             : 
   12528         440 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
   12529          72 :         dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
   12530             :                 qtypname, NULL,
   12531          72 :                 tyinfo->dobj.namespace->dobj.name,
   12532             :                 NULL, tyinfo->rolname, &tyinfo->dacl);
   12533             : 
   12534             :     /* Dump any per-constraint comments */
   12535         736 :     for (i = 0; i < tyinfo->nDomChecks; i++)
   12536             :     {
   12537         296 :         ConstraintInfo *domcheck = &(tyinfo->domChecks[i]);
   12538         296 :         PQExpBuffer conprefix = createPQExpBuffer();
   12539             : 
   12540         296 :         appendPQExpBuffer(conprefix, "CONSTRAINT %s ON DOMAIN",
   12541         296 :                           fmtId(domcheck->dobj.name));
   12542             : 
   12543         296 :         if (domcheck->dobj.dump & DUMP_COMPONENT_COMMENT)
   12544          72 :             dumpComment(fout, conprefix->data, qtypname,
   12545          72 :                         tyinfo->dobj.namespace->dobj.name,
   12546             :                         tyinfo->rolname,
   12547             :                         domcheck->dobj.catId, 0, tyinfo->dobj.dumpId);
   12548             : 
   12549         296 :         destroyPQExpBuffer(conprefix);
   12550             :     }
   12551             : 
   12552         440 :     destroyPQExpBuffer(q);
   12553         440 :     destroyPQExpBuffer(delq);
   12554         440 :     destroyPQExpBuffer(query);
   12555         440 :     free(qtypname);
   12556         440 :     free(qualtypname);
   12557         440 : }
   12558             : 
   12559             : /*
   12560             :  * dumpCompositeType
   12561             :  *    writes out to fout the queries to recreate a user-defined stand-alone
   12562             :  *    composite type
   12563             :  */
   12564             : static void
   12565         364 : dumpCompositeType(Archive *fout, const TypeInfo *tyinfo)
   12566             : {
   12567         364 :     DumpOptions *dopt = fout->dopt;
   12568         364 :     PQExpBuffer q = createPQExpBuffer();
   12569         364 :     PQExpBuffer dropped = createPQExpBuffer();
   12570         364 :     PQExpBuffer delq = createPQExpBuffer();
   12571         364 :     PQExpBuffer query = createPQExpBuffer();
   12572             :     PGresult   *res;
   12573             :     char       *qtypname;
   12574             :     char       *qualtypname;
   12575             :     int         ntups;
   12576             :     int         i_attname;
   12577             :     int         i_atttypdefn;
   12578             :     int         i_attlen;
   12579             :     int         i_attalign;
   12580             :     int         i_attisdropped;
   12581             :     int         i_attcollation;
   12582             :     int         i;
   12583             :     int         actual_atts;
   12584             : 
   12585         364 :     if (!fout->is_prepared[PREPQUERY_DUMPCOMPOSITETYPE])
   12586             :     {
   12587             :         /*
   12588             :          * Set up query for type-specific details.
   12589             :          *
   12590             :          * Since we only want to dump COLLATE clauses for attributes whose
   12591             :          * collation is different from their type's default, we use a CASE
   12592             :          * here to suppress uninteresting attcollations cheaply.  atttypid
   12593             :          * will be 0 for dropped columns; collation does not matter for those.
   12594             :          */
   12595         124 :         appendPQExpBufferStr(query,
   12596             :                              "PREPARE dumpCompositeType(pg_catalog.oid) AS\n"
   12597             :                              "SELECT a.attname, a.attnum, "
   12598             :                              "pg_catalog.format_type(a.atttypid, a.atttypmod) AS atttypdefn, "
   12599             :                              "a.attlen, a.attalign, a.attisdropped, "
   12600             :                              "CASE WHEN a.attcollation <> at.typcollation "
   12601             :                              "THEN a.attcollation ELSE 0 END AS attcollation "
   12602             :                              "FROM pg_catalog.pg_type ct "
   12603             :                              "JOIN pg_catalog.pg_attribute a ON a.attrelid = ct.typrelid "
   12604             :                              "LEFT JOIN pg_catalog.pg_type at ON at.oid = a.atttypid "
   12605             :                              "WHERE ct.oid = $1 "
   12606             :                              "ORDER BY a.attnum");
   12607             : 
   12608         124 :         ExecuteSqlStatement(fout, query->data);
   12609             : 
   12610         124 :         fout->is_prepared[PREPQUERY_DUMPCOMPOSITETYPE] = true;
   12611             :     }
   12612             : 
   12613         364 :     printfPQExpBuffer(query,
   12614             :                       "EXECUTE dumpCompositeType('%u')",
   12615             :                       tyinfo->dobj.catId.oid);
   12616             : 
   12617         364 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   12618             : 
   12619         364 :     ntups = PQntuples(res);
   12620             : 
   12621         364 :     i_attname = PQfnumber(res, "attname");
   12622         364 :     i_atttypdefn = PQfnumber(res, "atttypdefn");
   12623         364 :     i_attlen = PQfnumber(res, "attlen");
   12624         364 :     i_attalign = PQfnumber(res, "attalign");
   12625         364 :     i_attisdropped = PQfnumber(res, "attisdropped");
   12626         364 :     i_attcollation = PQfnumber(res, "attcollation");
   12627             : 
   12628         364 :     if (dopt->binary_upgrade)
   12629             :     {
   12630          36 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   12631             :                                                  tyinfo->dobj.catId.oid,
   12632             :                                                  false, false);
   12633          36 :         binary_upgrade_set_pg_class_oids(fout, q, tyinfo->typrelid);
   12634             :     }
   12635             : 
   12636         364 :     qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
   12637         364 :     qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
   12638             : 
   12639         364 :     appendPQExpBuffer(q, "CREATE TYPE %s AS (",
   12640             :                       qualtypname);
   12641             : 
   12642         364 :     actual_atts = 0;
   12643        1180 :     for (i = 0; i < ntups; i++)
   12644             :     {
   12645             :         char       *attname;
   12646             :         char       *atttypdefn;
   12647             :         char       *attlen;
   12648             :         char       *attalign;
   12649             :         bool        attisdropped;
   12650             :         Oid         attcollation;
   12651             : 
   12652         816 :         attname = PQgetvalue(res, i, i_attname);
   12653         816 :         atttypdefn = PQgetvalue(res, i, i_atttypdefn);
   12654         816 :         attlen = PQgetvalue(res, i, i_attlen);
   12655         816 :         attalign = PQgetvalue(res, i, i_attalign);
   12656         816 :         attisdropped = (PQgetvalue(res, i, i_attisdropped)[0] == 't');
   12657         816 :         attcollation = atooid(PQgetvalue(res, i, i_attcollation));
   12658             : 
   12659         816 :         if (attisdropped && !dopt->binary_upgrade)
   12660          24 :             continue;
   12661             : 
   12662             :         /* Format properly if not first attr */
   12663         792 :         if (actual_atts++ > 0)
   12664         428 :             appendPQExpBufferChar(q, ',');
   12665         792 :         appendPQExpBufferStr(q, "\n\t");
   12666             : 
   12667         792 :         if (!attisdropped)
   12668             :         {
   12669         788 :             appendPQExpBuffer(q, "%s %s", fmtId(attname), atttypdefn);
   12670             : 
   12671             :             /* Add collation if not default for the column type */
   12672         788 :             if (OidIsValid(attcollation))
   12673             :             {
   12674             :                 CollInfo   *coll;
   12675             : 
   12676           0 :                 coll = findCollationByOid(attcollation);
   12677           0 :                 if (coll)
   12678           0 :                     appendPQExpBuffer(q, " COLLATE %s",
   12679           0 :                                       fmtQualifiedDumpable(coll));
   12680             :             }
   12681             :         }
   12682             :         else
   12683             :         {
   12684             :             /*
   12685             :              * This is a dropped attribute and we're in binary_upgrade mode.
   12686             :              * Insert a placeholder for it in the CREATE TYPE command, and set
   12687             :              * length and alignment with direct UPDATE to the catalogs
   12688             :              * afterwards. See similar code in dumpTableSchema().
   12689             :              */
   12690           4 :             appendPQExpBuffer(q, "%s INTEGER /* dummy */", fmtId(attname));
   12691             : 
   12692             :             /* stash separately for insertion after the CREATE TYPE */
   12693           4 :             appendPQExpBufferStr(dropped,
   12694             :                                  "\n-- For binary upgrade, recreate dropped column.\n");
   12695           4 :             appendPQExpBuffer(dropped, "UPDATE pg_catalog.pg_attribute\n"
   12696             :                               "SET attlen = %s, "
   12697             :                               "attalign = '%s', attbyval = false\n"
   12698             :                               "WHERE attname = ", attlen, attalign);
   12699           4 :             appendStringLiteralAH(dropped, attname, fout);
   12700           4 :             appendPQExpBufferStr(dropped, "\n  AND attrelid = ");
   12701           4 :             appendStringLiteralAH(dropped, qualtypname, fout);
   12702           4 :             appendPQExpBufferStr(dropped, "::pg_catalog.regclass;\n");
   12703             : 
   12704           4 :             appendPQExpBuffer(dropped, "ALTER TYPE %s ",
   12705             :                               qualtypname);
   12706           4 :             appendPQExpBuffer(dropped, "DROP ATTRIBUTE %s;\n",
   12707             :                               fmtId(attname));
   12708             :         }
   12709             :     }
   12710         364 :     appendPQExpBufferStr(q, "\n);\n");
   12711         364 :     appendPQExpBufferStr(q, dropped->data);
   12712             : 
   12713         364 :     appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
   12714             : 
   12715         364 :     if (dopt->binary_upgrade)
   12716          36 :         binary_upgrade_extension_member(q, &tyinfo->dobj,
   12717             :                                         "TYPE", qtypname,
   12718          36 :                                         tyinfo->dobj.namespace->dobj.name);
   12719             : 
   12720         364 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12721         330 :         ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
   12722         330 :                      ARCHIVE_OPTS(.tag = tyinfo->dobj.name,
   12723             :                                   .namespace = tyinfo->dobj.namespace->dobj.name,
   12724             :                                   .owner = tyinfo->rolname,
   12725             :                                   .description = "TYPE",
   12726             :                                   .section = SECTION_PRE_DATA,
   12727             :                                   .createStmt = q->data,
   12728             :                                   .dropStmt = delq->data));
   12729             : 
   12730             : 
   12731             :     /* Dump Type Comments and Security Labels */
   12732         364 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   12733          72 :         dumpComment(fout, "TYPE", qtypname,
   12734          72 :                     tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12735             :                     tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12736             : 
   12737         364 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   12738           0 :         dumpSecLabel(fout, "TYPE", qtypname,
   12739           0 :                      tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
   12740             :                      tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
   12741             : 
   12742         364 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
   12743          36 :         dumpACL(fout, tyinfo->dobj.dumpId, InvalidDumpId, "TYPE",
   12744             :                 qtypname, NULL,
   12745          36 :                 tyinfo->dobj.namespace->dobj.name,
   12746             :                 NULL, tyinfo->rolname, &tyinfo->dacl);
   12747             : 
   12748             :     /* Dump any per-column comments */
   12749         364 :     if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   12750          72 :         dumpCompositeTypeColComments(fout, tyinfo, res);
   12751             : 
   12752         364 :     PQclear(res);
   12753         364 :     destroyPQExpBuffer(q);
   12754         364 :     destroyPQExpBuffer(dropped);
   12755         364 :     destroyPQExpBuffer(delq);
   12756         364 :     destroyPQExpBuffer(query);
   12757         364 :     free(qtypname);
   12758         364 :     free(qualtypname);
   12759         364 : }
   12760             : 
   12761             : /*
   12762             :  * dumpCompositeTypeColComments
   12763             :  *    writes out to fout the queries to recreate comments on the columns of
   12764             :  *    a user-defined stand-alone composite type.
   12765             :  *
   12766             :  * The caller has already made a query to collect the names and attnums
   12767             :  * of the type's columns, so we just pass that result into here rather
   12768             :  * than reading them again.
   12769             :  */
   12770             : static void
   12771          72 : dumpCompositeTypeColComments(Archive *fout, const TypeInfo *tyinfo,
   12772             :                              PGresult *res)
   12773             : {
   12774             :     CommentItem *comments;
   12775             :     int         ncomments;
   12776             :     PQExpBuffer query;
   12777             :     PQExpBuffer target;
   12778             :     int         i;
   12779             :     int         ntups;
   12780             :     int         i_attname;
   12781             :     int         i_attnum;
   12782             :     int         i_attisdropped;
   12783             : 
   12784             :     /* do nothing, if --no-comments is supplied */
   12785          72 :     if (fout->dopt->no_comments)
   12786           0 :         return;
   12787             : 
   12788             :     /* Search for comments associated with type's pg_class OID */
   12789          72 :     ncomments = findComments(RelationRelationId, tyinfo->typrelid,
   12790             :                              &comments);
   12791             : 
   12792             :     /* If no comments exist, we're done */
   12793          72 :     if (ncomments <= 0)
   12794           0 :         return;
   12795             : 
   12796             :     /* Build COMMENT ON statements */
   12797          72 :     query = createPQExpBuffer();
   12798          72 :     target = createPQExpBuffer();
   12799             : 
   12800          72 :     ntups = PQntuples(res);
   12801          72 :     i_attnum = PQfnumber(res, "attnum");
   12802          72 :     i_attname = PQfnumber(res, "attname");
   12803          72 :     i_attisdropped = PQfnumber(res, "attisdropped");
   12804         144 :     while (ncomments > 0)
   12805             :     {
   12806             :         const char *attname;
   12807             : 
   12808          72 :         attname = NULL;
   12809          72 :         for (i = 0; i < ntups; i++)
   12810             :         {
   12811          72 :             if (atoi(PQgetvalue(res, i, i_attnum)) == comments->objsubid &&
   12812          72 :                 PQgetvalue(res, i, i_attisdropped)[0] != 't')
   12813             :             {
   12814          72 :                 attname = PQgetvalue(res, i, i_attname);
   12815          72 :                 break;
   12816             :             }
   12817             :         }
   12818          72 :         if (attname)            /* just in case we don't find it */
   12819             :         {
   12820          72 :             const char *descr = comments->descr;
   12821             : 
   12822          72 :             resetPQExpBuffer(target);
   12823          72 :             appendPQExpBuffer(target, "COLUMN %s.",
   12824          72 :                               fmtId(tyinfo->dobj.name));
   12825          72 :             appendPQExpBufferStr(target, fmtId(attname));
   12826             : 
   12827          72 :             resetPQExpBuffer(query);
   12828          72 :             appendPQExpBuffer(query, "COMMENT ON COLUMN %s.",
   12829          72 :                               fmtQualifiedDumpable(tyinfo));
   12830          72 :             appendPQExpBuffer(query, "%s IS ", fmtId(attname));
   12831          72 :             appendStringLiteralAH(query, descr, fout);
   12832          72 :             appendPQExpBufferStr(query, ";\n");
   12833             : 
   12834          72 :             ArchiveEntry(fout, nilCatalogId, createDumpId(),
   12835          72 :                          ARCHIVE_OPTS(.tag = target->data,
   12836             :                                       .namespace = tyinfo->dobj.namespace->dobj.name,
   12837             :                                       .owner = tyinfo->rolname,
   12838             :                                       .description = "COMMENT",
   12839             :                                       .section = SECTION_NONE,
   12840             :                                       .createStmt = query->data,
   12841             :                                       .deps = &(tyinfo->dobj.dumpId),
   12842             :                                       .nDeps = 1));
   12843             :         }
   12844             : 
   12845          72 :         comments++;
   12846          72 :         ncomments--;
   12847             :     }
   12848             : 
   12849          72 :     destroyPQExpBuffer(query);
   12850          72 :     destroyPQExpBuffer(target);
   12851             : }
   12852             : 
   12853             : /*
   12854             :  * dumpShellType
   12855             :  *    writes out to fout the queries to create a shell type
   12856             :  *
   12857             :  * We dump a shell definition in advance of the I/O functions for the type.
   12858             :  */
   12859             : static void
   12860         196 : dumpShellType(Archive *fout, const ShellTypeInfo *stinfo)
   12861             : {
   12862         196 :     DumpOptions *dopt = fout->dopt;
   12863             :     PQExpBuffer q;
   12864             : 
   12865             :     /* Do nothing if not dumping schema */
   12866         196 :     if (!dopt->dumpSchema)
   12867          12 :         return;
   12868             : 
   12869         184 :     q = createPQExpBuffer();
   12870             : 
   12871             :     /*
   12872             :      * Note the lack of a DROP command for the shell type; any required DROP
   12873             :      * is driven off the base type entry, instead.  This interacts with
   12874             :      * _printTocEntry()'s use of the presence of a DROP command to decide
   12875             :      * whether an entry needs an ALTER OWNER command.  We don't want to alter
   12876             :      * the shell type's owner immediately on creation; that should happen only
   12877             :      * after it's filled in, otherwise the backend complains.
   12878             :      */
   12879             : 
   12880         184 :     if (dopt->binary_upgrade)
   12881          16 :         binary_upgrade_set_type_oids_by_type_oid(fout, q,
   12882          16 :                                                  stinfo->baseType->dobj.catId.oid,
   12883             :                                                  false, false);
   12884             : 
   12885         184 :     appendPQExpBuffer(q, "CREATE TYPE %s;\n",
   12886         184 :                       fmtQualifiedDumpable(stinfo));
   12887             : 
   12888         184 :     if (stinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12889         184 :         ArchiveEntry(fout, stinfo->dobj.catId, stinfo->dobj.dumpId,
   12890         184 :                      ARCHIVE_OPTS(.tag = stinfo->dobj.name,
   12891             :                                   .namespace = stinfo->dobj.namespace->dobj.name,
   12892             :                                   .owner = stinfo->baseType->rolname,
   12893             :                                   .description = "SHELL TYPE",
   12894             :                                   .section = SECTION_PRE_DATA,
   12895             :                                   .createStmt = q->data));
   12896             : 
   12897         184 :     destroyPQExpBuffer(q);
   12898             : }
   12899             : 
   12900             : /*
   12901             :  * dumpProcLang
   12902             :  *        writes out to fout the queries to recreate a user-defined
   12903             :  *        procedural language
   12904             :  */
   12905             : static void
   12906         180 : dumpProcLang(Archive *fout, const ProcLangInfo *plang)
   12907             : {
   12908         180 :     DumpOptions *dopt = fout->dopt;
   12909             :     PQExpBuffer defqry;
   12910             :     PQExpBuffer delqry;
   12911             :     bool        useParams;
   12912             :     char       *qlanname;
   12913             :     FuncInfo   *funcInfo;
   12914         180 :     FuncInfo   *inlineInfo = NULL;
   12915         180 :     FuncInfo   *validatorInfo = NULL;
   12916             : 
   12917             :     /* Do nothing if not dumping schema */
   12918         180 :     if (!dopt->dumpSchema)
   12919          26 :         return;
   12920             : 
   12921             :     /*
   12922             :      * Try to find the support function(s).  It is not an error if we don't
   12923             :      * find them --- if the functions are in the pg_catalog schema, as is
   12924             :      * standard in 8.1 and up, then we won't have loaded them. (In this case
   12925             :      * we will emit a parameterless CREATE LANGUAGE command, which will
   12926             :      * require PL template knowledge in the backend to reload.)
   12927             :      */
   12928             : 
   12929         154 :     funcInfo = findFuncByOid(plang->lanplcallfoid);
   12930         154 :     if (funcInfo != NULL && !funcInfo->dobj.dump)
   12931           4 :         funcInfo = NULL;        /* treat not-dumped same as not-found */
   12932             : 
   12933         154 :     if (OidIsValid(plang->laninline))
   12934             :     {
   12935          84 :         inlineInfo = findFuncByOid(plang->laninline);
   12936          84 :         if (inlineInfo != NULL && !inlineInfo->dobj.dump)
   12937           2 :             inlineInfo = NULL;
   12938             :     }
   12939             : 
   12940         154 :     if (OidIsValid(plang->lanvalidator))
   12941             :     {
   12942          84 :         validatorInfo = findFuncByOid(plang->lanvalidator);
   12943          84 :         if (validatorInfo != NULL && !validatorInfo->dobj.dump)
   12944           2 :             validatorInfo = NULL;
   12945             :     }
   12946             : 
   12947             :     /*
   12948             :      * If the functions are dumpable then emit a complete CREATE LANGUAGE with
   12949             :      * parameters.  Otherwise, we'll write a parameterless command, which will
   12950             :      * be interpreted as CREATE EXTENSION.
   12951             :      */
   12952          68 :     useParams = (funcInfo != NULL &&
   12953         290 :                  (inlineInfo != NULL || !OidIsValid(plang->laninline)) &&
   12954          68 :                  (validatorInfo != NULL || !OidIsValid(plang->lanvalidator)));
   12955             : 
   12956         154 :     defqry = createPQExpBuffer();
   12957         154 :     delqry = createPQExpBuffer();
   12958             : 
   12959         154 :     qlanname = pg_strdup(fmtId(plang->dobj.name));
   12960             : 
   12961         154 :     appendPQExpBuffer(delqry, "DROP PROCEDURAL LANGUAGE %s;\n",
   12962             :                       qlanname);
   12963             : 
   12964         154 :     if (useParams)
   12965             :     {
   12966          68 :         appendPQExpBuffer(defqry, "CREATE %sPROCEDURAL LANGUAGE %s",
   12967          68 :                           plang->lanpltrusted ? "TRUSTED " : "",
   12968             :                           qlanname);
   12969          68 :         appendPQExpBuffer(defqry, " HANDLER %s",
   12970          68 :                           fmtQualifiedDumpable(funcInfo));
   12971          68 :         if (OidIsValid(plang->laninline))
   12972           0 :             appendPQExpBuffer(defqry, " INLINE %s",
   12973           0 :                               fmtQualifiedDumpable(inlineInfo));
   12974          68 :         if (OidIsValid(plang->lanvalidator))
   12975           0 :             appendPQExpBuffer(defqry, " VALIDATOR %s",
   12976           0 :                               fmtQualifiedDumpable(validatorInfo));
   12977             :     }
   12978             :     else
   12979             :     {
   12980             :         /*
   12981             :          * If not dumping parameters, then use CREATE OR REPLACE so that the
   12982             :          * command will not fail if the language is preinstalled in the target
   12983             :          * database.
   12984             :          *
   12985             :          * Modern servers will interpret this as CREATE EXTENSION IF NOT
   12986             :          * EXISTS; perhaps we should emit that instead?  But it might just add
   12987             :          * confusion.
   12988             :          */
   12989          86 :         appendPQExpBuffer(defqry, "CREATE OR REPLACE PROCEDURAL LANGUAGE %s",
   12990             :                           qlanname);
   12991             :     }
   12992         154 :     appendPQExpBufferStr(defqry, ";\n");
   12993             : 
   12994         154 :     if (dopt->binary_upgrade)
   12995           4 :         binary_upgrade_extension_member(defqry, &plang->dobj,
   12996             :                                         "LANGUAGE", qlanname, NULL);
   12997             : 
   12998         154 :     if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
   12999          70 :         ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
   13000          70 :                      ARCHIVE_OPTS(.tag = plang->dobj.name,
   13001             :                                   .owner = plang->lanowner,
   13002             :                                   .description = "PROCEDURAL LANGUAGE",
   13003             :                                   .section = SECTION_PRE_DATA,
   13004             :                                   .createStmt = defqry->data,
   13005             :                                   .dropStmt = delqry->data,
   13006             :                                   ));
   13007             : 
   13008             :     /* Dump Proc Lang Comments and Security Labels */
   13009         154 :     if (plang->dobj.dump & DUMP_COMPONENT_COMMENT)
   13010           0 :         dumpComment(fout, "LANGUAGE", qlanname,
   13011             :                     NULL, plang->lanowner,
   13012             :                     plang->dobj.catId, 0, plang->dobj.dumpId);
   13013             : 
   13014         154 :     if (plang->dobj.dump & DUMP_COMPONENT_SECLABEL)
   13015           0 :         dumpSecLabel(fout, "LANGUAGE", qlanname,
   13016             :                      NULL, plang->lanowner,
   13017             :                      plang->dobj.catId, 0, plang->dobj.dumpId);
   13018             : 
   13019         154 :     if (plang->lanpltrusted && plang->dobj.dump & DUMP_COMPONENT_ACL)
   13020          84 :         dumpACL(fout, plang->dobj.dumpId, InvalidDumpId, "LANGUAGE",
   13021             :                 qlanname, NULL, NULL,
   13022             :                 NULL, plang->lanowner, &plang->dacl);
   13023             : 
   13024         154 :     free(qlanname);
   13025             : 
   13026         154 :     destroyPQExpBuffer(defqry);
   13027         154 :     destroyPQExpBuffer(delqry);
   13028             : }
   13029             : 
   13030             : /*
   13031             :  * format_function_arguments: generate function name and argument list
   13032             :  *
   13033             :  * This is used when we can rely on pg_get_function_arguments to format
   13034             :  * the argument list.  Note, however, that pg_get_function_arguments
   13035             :  * does not special-case zero-argument aggregates.
   13036             :  */
   13037             : static char *
   13038       12224 : format_function_arguments(const FuncInfo *finfo, const char *funcargs, bool is_agg)
   13039             : {
   13040             :     PQExpBufferData fn;
   13041             : 
   13042       12224 :     initPQExpBuffer(&fn);
   13043       12224 :     appendPQExpBufferStr(&fn, fmtId(finfo->dobj.name));
   13044       12224 :     if (is_agg && finfo->nargs == 0)
   13045         256 :         appendPQExpBufferStr(&fn, "(*)");
   13046             :     else
   13047       11968 :         appendPQExpBuffer(&fn, "(%s)", funcargs);
   13048       12224 :     return fn.data;
   13049             : }
   13050             : 
   13051             : /*
   13052             :  * format_function_signature: generate function name and argument list
   13053             :  *
   13054             :  * Only a minimal list of input argument types is generated; this is
   13055             :  * sufficient to reference the function, but not to define it.
   13056             :  *
   13057             :  * If honor_quotes is false then the function name is never quoted.
   13058             :  * This is appropriate for use in TOC tags, but not in SQL commands.
   13059             :  */
   13060             : static char *
   13061        6370 : format_function_signature(Archive *fout, const FuncInfo *finfo, bool honor_quotes)
   13062             : {
   13063             :     PQExpBufferData fn;
   13064             :     int         j;
   13065             : 
   13066        6370 :     initPQExpBuffer(&fn);
   13067        6370 :     if (honor_quotes)
   13068        1118 :         appendPQExpBuffer(&fn, "%s(", fmtId(finfo->dobj.name));
   13069             :     else
   13070        5252 :         appendPQExpBuffer(&fn, "%s(", finfo->dobj.name);
   13071       11838 :     for (j = 0; j < finfo->nargs; j++)
   13072             :     {
   13073        5468 :         if (j > 0)
   13074        1348 :             appendPQExpBufferStr(&fn, ", ");
   13075             : 
   13076        5468 :         appendPQExpBufferStr(&fn,
   13077        5468 :                              getFormattedTypeName(fout, finfo->argtypes[j],
   13078             :                                                   zeroIsError));
   13079             :     }
   13080        6370 :     appendPQExpBufferChar(&fn, ')');
   13081        6370 :     return fn.data;
   13082             : }
   13083             : 
   13084             : 
   13085             : /*
   13086             :  * dumpFunc:
   13087             :  *    dump out one function
   13088             :  */
   13089             : static void
   13090        5376 : dumpFunc(Archive *fout, const FuncInfo *finfo)
   13091             : {
   13092        5376 :     DumpOptions *dopt = fout->dopt;
   13093             :     PQExpBuffer query;
   13094             :     PQExpBuffer q;
   13095             :     PQExpBuffer delqry;
   13096             :     PQExpBuffer asPart;
   13097             :     PGresult   *res;
   13098             :     char       *funcsig;        /* identity signature */
   13099        5376 :     char       *funcfullsig = NULL; /* full signature */
   13100             :     char       *funcsig_tag;
   13101             :     char       *qual_funcsig;
   13102             :     char       *proretset;
   13103             :     char       *prosrc;
   13104             :     char       *probin;
   13105             :     char       *prosqlbody;
   13106             :     char       *funcargs;
   13107             :     char       *funciargs;
   13108             :     char       *funcresult;
   13109             :     char       *protrftypes;
   13110             :     char       *prokind;
   13111             :     char       *provolatile;
   13112             :     char       *proisstrict;
   13113             :     char       *prosecdef;
   13114             :     char       *proleakproof;
   13115             :     char       *proconfig;
   13116             :     char       *procost;
   13117             :     char       *prorows;
   13118             :     char       *prosupport;
   13119             :     char       *proparallel;
   13120             :     char       *lanname;
   13121        5376 :     char      **configitems = NULL;
   13122        5376 :     int         nconfigitems = 0;
   13123             :     const char *keyword;
   13124             : 
   13125             :     /* Do nothing if not dumping schema */
   13126        5376 :     if (!dopt->dumpSchema)
   13127         124 :         return;
   13128             : 
   13129        5252 :     query = createPQExpBuffer();
   13130        5252 :     q = createPQExpBuffer();
   13131        5252 :     delqry = createPQExpBuffer();
   13132        5252 :     asPart = createPQExpBuffer();
   13133             : 
   13134        5252 :     if (!fout->is_prepared[PREPQUERY_DUMPFUNC])
   13135             :     {
   13136             :         /* Set up query for function-specific details */
   13137         150 :         appendPQExpBufferStr(query,
   13138             :                              "PREPARE dumpFunc(pg_catalog.oid) AS\n");
   13139             : 
   13140         150 :         appendPQExpBufferStr(query,
   13141             :                              "SELECT\n"
   13142             :                              "proretset,\n"
   13143             :                              "prosrc,\n"
   13144             :                              "probin,\n"
   13145             :                              "provolatile,\n"
   13146             :                              "proisstrict,\n"
   13147             :                              "prosecdef,\n"
   13148             :                              "lanname,\n"
   13149             :                              "proconfig,\n"
   13150             :                              "procost,\n"
   13151             :                              "prorows,\n"
   13152             :                              "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
   13153             :                              "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n"
   13154             :                              "pg_catalog.pg_get_function_result(p.oid) AS funcresult,\n"
   13155             :                              "proleakproof,\n");
   13156             : 
   13157         150 :         if (fout->remoteVersion >= 90500)
   13158         150 :             appendPQExpBufferStr(query,
   13159             :                                  "array_to_string(protrftypes, ' ') AS protrftypes,\n");
   13160             :         else
   13161           0 :             appendPQExpBufferStr(query,
   13162             :                                  "NULL AS protrftypes,\n");
   13163             : 
   13164         150 :         if (fout->remoteVersion >= 90600)
   13165         150 :             appendPQExpBufferStr(query,
   13166             :                                  "proparallel,\n");
   13167             :         else
   13168           0 :             appendPQExpBufferStr(query,
   13169             :                                  "'u' AS proparallel,\n");
   13170             : 
   13171         150 :         if (fout->remoteVersion >= 110000)
   13172         150 :             appendPQExpBufferStr(query,
   13173             :                                  "prokind,\n");
   13174             :         else
   13175           0 :             appendPQExpBufferStr(query,
   13176             :                                  "CASE WHEN proiswindow THEN 'w' ELSE 'f' END AS prokind,\n");
   13177             : 
   13178         150 :         if (fout->remoteVersion >= 120000)
   13179         150 :             appendPQExpBufferStr(query,
   13180             :                                  "prosupport,\n");
   13181             :         else
   13182           0 :             appendPQExpBufferStr(query,
   13183             :                                  "'-' AS prosupport,\n");
   13184             : 
   13185         150 :         if (fout->remoteVersion >= 140000)
   13186         150 :             appendPQExpBufferStr(query,
   13187             :                                  "pg_get_function_sqlbody(p.oid) AS prosqlbody\n");
   13188             :         else
   13189           0 :             appendPQExpBufferStr(query,
   13190             :                                  "NULL AS prosqlbody\n");
   13191             : 
   13192         150 :         appendPQExpBufferStr(query,
   13193             :                              "FROM pg_catalog.pg_proc p, pg_catalog.pg_language l\n"
   13194             :                              "WHERE p.oid = $1 "
   13195             :                              "AND l.oid = p.prolang");
   13196             : 
   13197         150 :         ExecuteSqlStatement(fout, query->data);
   13198             : 
   13199         150 :         fout->is_prepared[PREPQUERY_DUMPFUNC] = true;
   13200             :     }
   13201             : 
   13202        5252 :     printfPQExpBuffer(query,
   13203             :                       "EXECUTE dumpFunc('%u')",
   13204             :                       finfo->dobj.catId.oid);
   13205             : 
   13206        5252 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   13207             : 
   13208        5252 :     proretset = PQgetvalue(res, 0, PQfnumber(res, "proretset"));
   13209        5252 :     if (PQgetisnull(res, 0, PQfnumber(res, "prosqlbody")))
   13210             :     {
   13211        5130 :         prosrc = PQgetvalue(res, 0, PQfnumber(res, "prosrc"));
   13212        5130 :         probin = PQgetvalue(res, 0, PQfnumber(res, "probin"));
   13213        5130 :         prosqlbody = NULL;
   13214             :     }
   13215             :     else
   13216             :     {
   13217         122 :         prosrc = NULL;
   13218         122 :         probin = NULL;
   13219         122 :         prosqlbody = PQgetvalue(res, 0, PQfnumber(res, "prosqlbody"));
   13220             :     }
   13221        5252 :     funcargs = PQgetvalue(res, 0, PQfnumber(res, "funcargs"));
   13222        5252 :     funciargs = PQgetvalue(res, 0, PQfnumber(res, "funciargs"));
   13223        5252 :     funcresult = PQgetvalue(res, 0, PQfnumber(res, "funcresult"));
   13224        5252 :     protrftypes = PQgetvalue(res, 0, PQfnumber(res, "protrftypes"));
   13225        5252 :     prokind = PQgetvalue(res, 0, PQfnumber(res, "prokind"));
   13226        5252 :     provolatile = PQgetvalue(res, 0, PQfnumber(res, "provolatile"));
   13227        5252 :     proisstrict = PQgetvalue(res, 0, PQfnumber(res, "proisstrict"));
   13228        5252 :     prosecdef = PQgetvalue(res, 0, PQfnumber(res, "prosecdef"));
   13229        5252 :     proleakproof = PQgetvalue(res, 0, PQfnumber(res, "proleakproof"));
   13230        5252 :     proconfig = PQgetvalue(res, 0, PQfnumber(res, "proconfig"));
   13231        5252 :     procost = PQgetvalue(res, 0, PQfnumber(res, "procost"));
   13232        5252 :     prorows = PQgetvalue(res, 0, PQfnumber(res, "prorows"));
   13233        5252 :     prosupport = PQgetvalue(res, 0, PQfnumber(res, "prosupport"));
   13234        5252 :     proparallel = PQgetvalue(res, 0, PQfnumber(res, "proparallel"));
   13235        5252 :     lanname = PQgetvalue(res, 0, PQfnumber(res, "lanname"));
   13236             : 
   13237             :     /*
   13238             :      * See backend/commands/functioncmds.c for details of how the 'AS' clause
   13239             :      * is used.
   13240             :      */
   13241        5252 :     if (prosqlbody)
   13242             :     {
   13243         122 :         appendPQExpBufferStr(asPart, prosqlbody);
   13244             :     }
   13245        5130 :     else if (probin[0] != '\0')
   13246             :     {
   13247         392 :         appendPQExpBufferStr(asPart, "AS ");
   13248         392 :         appendStringLiteralAH(asPart, probin, fout);
   13249         392 :         if (prosrc[0] != '\0')
   13250             :         {
   13251         392 :             appendPQExpBufferStr(asPart, ", ");
   13252             : 
   13253             :             /*
   13254             :              * where we have bin, use dollar quoting if allowed and src
   13255             :              * contains quote or backslash; else use regular quoting.
   13256             :              */
   13257         392 :             if (dopt->disable_dollar_quoting ||
   13258         392 :                 (strchr(prosrc, '\'') == NULL && strchr(prosrc, '\\') == NULL))
   13259         392 :                 appendStringLiteralAH(asPart, prosrc, fout);
   13260             :             else
   13261           0 :                 appendStringLiteralDQ(asPart, prosrc, NULL);
   13262             :         }
   13263             :     }
   13264             :     else
   13265             :     {
   13266        4738 :         appendPQExpBufferStr(asPart, "AS ");
   13267             :         /* with no bin, dollar quote src unconditionally if allowed */
   13268        4738 :         if (dopt->disable_dollar_quoting)
   13269           0 :             appendStringLiteralAH(asPart, prosrc, fout);
   13270             :         else
   13271        4738 :             appendStringLiteralDQ(asPart, prosrc, NULL);
   13272             :     }
   13273             : 
   13274        5252 :     if (*proconfig)
   13275             :     {
   13276          48 :         if (!parsePGArray(proconfig, &configitems, &nconfigitems))
   13277           0 :             pg_fatal("could not parse %s array", "proconfig");
   13278             :     }
   13279             :     else
   13280             :     {
   13281        5204 :         configitems = NULL;
   13282        5204 :         nconfigitems = 0;
   13283             :     }
   13284             : 
   13285        5252 :     funcfullsig = format_function_arguments(finfo, funcargs, false);
   13286        5252 :     funcsig = format_function_arguments(finfo, funciargs, false);
   13287             : 
   13288        5252 :     funcsig_tag = format_function_signature(fout, finfo, false);
   13289             : 
   13290        5252 :     qual_funcsig = psprintf("%s.%s",
   13291        5252 :                             fmtId(finfo->dobj.namespace->dobj.name),
   13292             :                             funcsig);
   13293             : 
   13294        5252 :     if (prokind[0] == PROKIND_PROCEDURE)
   13295         264 :         keyword = "PROCEDURE";
   13296             :     else
   13297        4988 :         keyword = "FUNCTION"; /* works for window functions too */
   13298             : 
   13299        5252 :     appendPQExpBuffer(delqry, "DROP %s %s;\n",
   13300             :                       keyword, qual_funcsig);
   13301             : 
   13302       10504 :     appendPQExpBuffer(q, "CREATE %s %s.%s",
   13303             :                       keyword,
   13304        5252 :                       fmtId(finfo->dobj.namespace->dobj.name),
   13305             :                       funcfullsig ? funcfullsig :
   13306             :                       funcsig);
   13307             : 
   13308        5252 :     if (prokind[0] == PROKIND_PROCEDURE)
   13309             :          /* no result type to output */ ;
   13310        4988 :     else if (funcresult)
   13311        4988 :         appendPQExpBuffer(q, " RETURNS %s", funcresult);
   13312             :     else
   13313           0 :         appendPQExpBuffer(q, " RETURNS %s%s",
   13314           0 :                           (proretset[0] == 't') ? "SETOF " : "",
   13315             :                           getFormattedTypeName(fout, finfo->prorettype,
   13316             :                                                zeroIsError));
   13317             : 
   13318        5252 :     appendPQExpBuffer(q, "\n    LANGUAGE %s", fmtId(lanname));
   13319             : 
   13320        5252 :     if (*protrftypes)
   13321             :     {
   13322           0 :         Oid        *typeids = pg_malloc(FUNC_MAX_ARGS * sizeof(Oid));
   13323             :         int         i;
   13324             : 
   13325           0 :         appendPQExpBufferStr(q, " TRANSFORM ");
   13326           0 :         parseOidArray(protrftypes, typeids, FUNC_MAX_ARGS);
   13327           0 :         for (i = 0; typeids[i]; i++)
   13328             :         {
   13329           0 :             if (i != 0)
   13330           0 :                 appendPQExpBufferStr(q, ", ");
   13331           0 :             appendPQExpBuffer(q, "FOR TYPE %s",
   13332           0 :                               getFormattedTypeName(fout, typeids[i], zeroAsNone));
   13333             :         }
   13334             : 
   13335           0 :         free(typeids);
   13336             :     }
   13337             : 
   13338        5252 :     if (prokind[0] == PROKIND_WINDOW)
   13339          16 :         appendPQExpBufferStr(q, " WINDOW");
   13340             : 
   13341        5252 :     if (provolatile[0] != PROVOLATILE_VOLATILE)
   13342             :     {
   13343        1054 :         if (provolatile[0] == PROVOLATILE_IMMUTABLE)
   13344         988 :             appendPQExpBufferStr(q, " IMMUTABLE");
   13345          66 :         else if (provolatile[0] == PROVOLATILE_STABLE)
   13346          66 :             appendPQExpBufferStr(q, " STABLE");
   13347           0 :         else if (provolatile[0] != PROVOLATILE_VOLATILE)
   13348           0 :             pg_fatal("unrecognized provolatile value for function \"%s\"",
   13349             :                      finfo->dobj.name);
   13350             :     }
   13351             : 
   13352        5252 :     if (proisstrict[0] == 't')
   13353        1030 :         appendPQExpBufferStr(q, " STRICT");
   13354             : 
   13355        5252 :     if (prosecdef[0] == 't')
   13356           0 :         appendPQExpBufferStr(q, " SECURITY DEFINER");
   13357             : 
   13358        5252 :     if (proleakproof[0] == 't')
   13359          32 :         appendPQExpBufferStr(q, " LEAKPROOF");
   13360             : 
   13361             :     /*
   13362             :      * COST and ROWS are emitted only if present and not default, so as not to
   13363             :      * break backwards-compatibility of the dump without need.  Keep this code
   13364             :      * in sync with the defaults in functioncmds.c.
   13365             :      */
   13366        5252 :     if (strcmp(procost, "0") != 0)
   13367             :     {
   13368        5252 :         if (strcmp(lanname, "internal") == 0 || strcmp(lanname, "c") == 0)
   13369             :         {
   13370             :             /* default cost is 1 */
   13371         996 :             if (strcmp(procost, "1") != 0)
   13372           0 :                 appendPQExpBuffer(q, " COST %s", procost);
   13373             :         }
   13374             :         else
   13375             :         {
   13376             :             /* default cost is 100 */
   13377        4256 :             if (strcmp(procost, "100") != 0)
   13378          18 :                 appendPQExpBuffer(q, " COST %s", procost);
   13379             :         }
   13380             :     }
   13381        5252 :     if (proretset[0] == 't' &&
   13382         568 :         strcmp(prorows, "0") != 0 && strcmp(prorows, "1000") != 0)
   13383           0 :         appendPQExpBuffer(q, " ROWS %s", prorows);
   13384             : 
   13385        5252 :     if (strcmp(prosupport, "-") != 0)
   13386             :     {
   13387             :         /* We rely on regprocout to provide quoting and qualification */
   13388         104 :         appendPQExpBuffer(q, " SUPPORT %s", prosupport);
   13389             :     }
   13390             : 
   13391        5252 :     if (proparallel[0] != PROPARALLEL_UNSAFE)
   13392             :     {
   13393         302 :         if (proparallel[0] == PROPARALLEL_SAFE)
   13394         286 :             appendPQExpBufferStr(q, " PARALLEL SAFE");
   13395          16 :         else if (proparallel[0] == PROPARALLEL_RESTRICTED)
   13396          16 :             appendPQExpBufferStr(q, " PARALLEL RESTRICTED");
   13397           0 :         else if (proparallel[0] != PROPARALLEL_UNSAFE)
   13398           0 :             pg_fatal("unrecognized proparallel value for function \"%s\"",
   13399             :                      finfo->dobj.name);
   13400             :     }
   13401             : 
   13402        5364 :     for (int i = 0; i < nconfigitems; i++)
   13403             :     {
   13404             :         /* we feel free to scribble on configitems[] here */
   13405         112 :         char       *configitem = configitems[i];
   13406             :         char       *pos;
   13407             : 
   13408         112 :         pos = strchr(configitem, '=');
   13409         112 :         if (pos == NULL)
   13410           0 :             continue;
   13411         112 :         *pos++ = '\0';
   13412         112 :         appendPQExpBuffer(q, "\n    SET %s TO ", fmtId(configitem));
   13413             : 
   13414             :         /*
   13415             :          * Variables that are marked GUC_LIST_QUOTE were already fully quoted
   13416             :          * by flatten_set_variable_args() before they were put into the
   13417             :          * proconfig array.  However, because the quoting rules used there
   13418             :          * aren't exactly like SQL's, we have to break the list value apart
   13419             :          * and then quote the elements as string literals.  (The elements may
   13420             :          * be double-quoted as-is, but we can't just feed them to the SQL
   13421             :          * parser; it would do the wrong thing with elements that are
   13422             :          * zero-length or longer than NAMEDATALEN.)
   13423             :          *
   13424             :          * Variables that are not so marked should just be emitted as simple
   13425             :          * string literals.  If the variable is not known to
   13426             :          * variable_is_guc_list_quote(), we'll do that; this makes it unsafe
   13427             :          * to use GUC_LIST_QUOTE for extension variables.
   13428             :          */
   13429         112 :         if (variable_is_guc_list_quote(configitem))
   13430             :         {
   13431             :             char      **namelist;
   13432             :             char      **nameptr;
   13433             : 
   13434             :             /* Parse string into list of identifiers */
   13435             :             /* this shouldn't fail really */
   13436          32 :             if (SplitGUCList(pos, ',', &namelist))
   13437             :             {
   13438         112 :                 for (nameptr = namelist; *nameptr; nameptr++)
   13439             :                 {
   13440          80 :                     if (nameptr != namelist)
   13441          48 :                         appendPQExpBufferStr(q, ", ");
   13442          80 :                     appendStringLiteralAH(q, *nameptr, fout);
   13443             :                 }
   13444             :             }
   13445          32 :             pg_free(namelist);
   13446             :         }
   13447             :         else
   13448          80 :             appendStringLiteralAH(q, pos, fout);
   13449             :     }
   13450             : 
   13451        5252 :     appendPQExpBuffer(q, "\n    %s;\n", asPart->data);
   13452             : 
   13453        5252 :     append_depends_on_extension(fout, q, &finfo->dobj,
   13454             :                                 "pg_catalog.pg_proc", keyword,
   13455             :                                 qual_funcsig);
   13456             : 
   13457        5252 :     if (dopt->binary_upgrade)
   13458         576 :         binary_upgrade_extension_member(q, &finfo->dobj,
   13459             :                                         keyword, funcsig,
   13460         576 :                                         finfo->dobj.namespace->dobj.name);
   13461             : 
   13462        5252 :     if (finfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   13463        5044 :         ArchiveEntry(fout, finfo->dobj.catId, finfo->dobj.dumpId,
   13464        5044 :                      ARCHIVE_OPTS(.tag = funcsig_tag,
   13465             :                                   .namespace = finfo->dobj.namespace->dobj.name,
   13466             :                                   .owner = finfo->rolname,
   13467             :                                   .description = keyword,
   13468             :                                   .section = finfo->postponed_def ?
   13469             :                                   SECTION_POST_DATA : SECTION_PRE_DATA,
   13470             :                                   .createStmt = q->data,
   13471             :                                   .dropStmt = delqry->data));
   13472             : 
   13473             :     /* Dump Function Comments and Security Labels */
   13474        5252 :     if (finfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   13475          18 :         dumpComment(fout, keyword, funcsig,
   13476          18 :                     finfo->dobj.namespace->dobj.name, finfo->rolname,
   13477             :                     finfo->dobj.catId, 0, finfo->dobj.dumpId);
   13478             : 
   13479        5252 :     if (finfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   13480           0 :         dumpSecLabel(fout, keyword, funcsig,
   13481           0 :                      finfo->dobj.namespace->dobj.name, finfo->rolname,
   13482             :                      finfo->dobj.catId, 0, finfo->dobj.dumpId);
   13483             : 
   13484        5252 :     if (finfo->dobj.dump & DUMP_COMPONENT_ACL)
   13485         230 :         dumpACL(fout, finfo->dobj.dumpId, InvalidDumpId, keyword,
   13486             :                 funcsig, NULL,
   13487         230 :                 finfo->dobj.namespace->dobj.name,
   13488             :                 NULL, finfo->rolname, &finfo->dacl);
   13489             : 
   13490        5252 :     PQclear(res);
   13491             : 
   13492        5252 :     destroyPQExpBuffer(query);
   13493        5252 :     destroyPQExpBuffer(q);
   13494        5252 :     destroyPQExpBuffer(delqry);
   13495        5252 :     destroyPQExpBuffer(asPart);
   13496        5252 :     free(funcsig);
   13497        5252 :     free(funcfullsig);
   13498        5252 :     free(funcsig_tag);
   13499        5252 :     free(qual_funcsig);
   13500        5252 :     free(configitems);
   13501             : }
   13502             : 
   13503             : 
   13504             : /*
   13505             :  * Dump a user-defined cast
   13506             :  */
   13507             : static void
   13508         178 : dumpCast(Archive *fout, const CastInfo *cast)
   13509             : {
   13510         178 :     DumpOptions *dopt = fout->dopt;
   13511             :     PQExpBuffer defqry;
   13512             :     PQExpBuffer delqry;
   13513             :     PQExpBuffer labelq;
   13514             :     PQExpBuffer castargs;
   13515         178 :     FuncInfo   *funcInfo = NULL;
   13516             :     const char *sourceType;
   13517             :     const char *targetType;
   13518             : 
   13519             :     /* Do nothing if not dumping schema */
   13520         178 :     if (!dopt->dumpSchema)
   13521          12 :         return;
   13522             : 
   13523             :     /* Cannot dump if we don't have the cast function's info */
   13524         166 :     if (OidIsValid(cast->castfunc))
   13525             :     {
   13526          86 :         funcInfo = findFuncByOid(cast->castfunc);
   13527          86 :         if (funcInfo == NULL)
   13528           0 :             pg_fatal("could not find function definition for function with OID %u",
   13529             :                      cast->castfunc);
   13530             :     }
   13531             : 
   13532         166 :     defqry = createPQExpBuffer();
   13533         166 :     delqry = createPQExpBuffer();
   13534         166 :     labelq = createPQExpBuffer();
   13535         166 :     castargs = createPQExpBuffer();
   13536             : 
   13537         166 :     sourceType = getFormattedTypeName(fout, cast->castsource, zeroAsNone);
   13538         166 :     targetType = getFormattedTypeName(fout, cast->casttarget, zeroAsNone);
   13539         166 :     appendPQExpBuffer(delqry, "DROP CAST (%s AS %s);\n",
   13540             :                       sourceType, targetType);
   13541             : 
   13542         166 :     appendPQExpBuffer(defqry, "CREATE CAST (%s AS %s) ",
   13543             :                       sourceType, targetType);
   13544             : 
   13545         166 :     switch (cast->castmethod)
   13546             :     {
   13547          80 :         case COERCION_METHOD_BINARY:
   13548          80 :             appendPQExpBufferStr(defqry, "WITHOUT FUNCTION");
   13549          80 :             break;
   13550           0 :         case COERCION_METHOD_INOUT:
   13551           0 :             appendPQExpBufferStr(defqry, "WITH INOUT");
   13552           0 :             break;
   13553          86 :         case COERCION_METHOD_FUNCTION:
   13554          86 :             if (funcInfo)
   13555             :             {
   13556          86 :                 char       *fsig = format_function_signature(fout, funcInfo, true);
   13557             : 
   13558             :                 /*
   13559             :                  * Always qualify the function name (format_function_signature
   13560             :                  * won't qualify it).
   13561             :                  */
   13562          86 :                 appendPQExpBuffer(defqry, "WITH FUNCTION %s.%s",
   13563          86 :                                   fmtId(funcInfo->dobj.namespace->dobj.name), fsig);
   13564          86 :                 free(fsig);
   13565             :             }
   13566             :             else
   13567           0 :                 pg_log_warning("bogus value in pg_cast.castfunc or pg_cast.castmethod field");
   13568          86 :             break;
   13569           0 :         default:
   13570           0 :             pg_log_warning("bogus value in pg_cast.castmethod field");
   13571             :     }
   13572             : 
   13573         166 :     if (cast->castcontext == 'a')
   13574          70 :         appendPQExpBufferStr(defqry, " AS ASSIGNMENT");
   13575          96 :     else if (cast->castcontext == 'i')
   13576          32 :         appendPQExpBufferStr(defqry, " AS IMPLICIT");
   13577         166 :     appendPQExpBufferStr(defqry, ";\n");
   13578             : 
   13579         166 :     appendPQExpBuffer(labelq, "CAST (%s AS %s)",
   13580             :                       sourceType, targetType);
   13581             : 
   13582         166 :     appendPQExpBuffer(castargs, "(%s AS %s)",
   13583             :                       sourceType, targetType);
   13584             : 
   13585         166 :     if (dopt->binary_upgrade)
   13586          14 :         binary_upgrade_extension_member(defqry, &cast->dobj,
   13587          14 :                                         "CAST", castargs->data, NULL);
   13588             : 
   13589         166 :     if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
   13590         166 :         ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
   13591         166 :                      ARCHIVE_OPTS(.tag = labelq->data,
   13592             :                                   .description = "CAST",
   13593             :                                   .section = SECTION_PRE_DATA,
   13594             :                                   .createStmt = defqry->data,
   13595             :                                   .dropStmt = delqry->data));
   13596             : 
   13597             :     /* Dump Cast Comments */
   13598         166 :     if (cast->dobj.dump & DUMP_COMPONENT_COMMENT)
   13599           0 :         dumpComment(fout, "CAST", castargs->data,
   13600             :                     NULL, "",
   13601             :                     cast->dobj.catId, 0, cast->dobj.dumpId);
   13602             : 
   13603         166 :     destroyPQExpBuffer(defqry);
   13604         166 :     destroyPQExpBuffer(delqry);
   13605         166 :     destroyPQExpBuffer(labelq);
   13606         166 :     destroyPQExpBuffer(castargs);
   13607             : }
   13608             : 
   13609             : /*
   13610             :  * Dump a transform
   13611             :  */
   13612             : static void
   13613          98 : dumpTransform(Archive *fout, const TransformInfo *transform)
   13614             : {
   13615          98 :     DumpOptions *dopt = fout->dopt;
   13616             :     PQExpBuffer defqry;
   13617             :     PQExpBuffer delqry;
   13618             :     PQExpBuffer labelq;
   13619             :     PQExpBuffer transformargs;
   13620          98 :     FuncInfo   *fromsqlFuncInfo = NULL;
   13621          98 :     FuncInfo   *tosqlFuncInfo = NULL;
   13622             :     char       *lanname;
   13623             :     const char *transformType;
   13624             : 
   13625             :     /* Do nothing if not dumping schema */
   13626          98 :     if (!dopt->dumpSchema)
   13627          12 :         return;
   13628             : 
   13629             :     /* Cannot dump if we don't have the transform functions' info */
   13630          86 :     if (OidIsValid(transform->trffromsql))
   13631             :     {
   13632          86 :         fromsqlFuncInfo = findFuncByOid(transform->trffromsql);
   13633          86 :         if (fromsqlFuncInfo == NULL)
   13634           0 :             pg_fatal("could not find function definition for function with OID %u",
   13635             :                      transform->trffromsql);
   13636             :     }
   13637          86 :     if (OidIsValid(transform->trftosql))
   13638             :     {
   13639          86 :         tosqlFuncInfo = findFuncByOid(transform->trftosql);
   13640          86 :         if (tosqlFuncInfo == NULL)
   13641           0 :             pg_fatal("could not find function definition for function with OID %u",
   13642             :                      transform->trftosql);
   13643             :     }
   13644             : 
   13645          86 :     defqry = createPQExpBuffer();
   13646          86 :     delqry = createPQExpBuffer();
   13647          86 :     labelq = createPQExpBuffer();
   13648          86 :     transformargs = createPQExpBuffer();
   13649             : 
   13650          86 :     lanname = get_language_name(fout, transform->trflang);
   13651          86 :     transformType = getFormattedTypeName(fout, transform->trftype, zeroAsNone);
   13652             : 
   13653          86 :     appendPQExpBuffer(delqry, "DROP TRANSFORM FOR %s LANGUAGE %s;\n",
   13654             :                       transformType, lanname);
   13655             : 
   13656          86 :     appendPQExpBuffer(defqry, "CREATE TRANSFORM FOR %s LANGUAGE %s (",
   13657             :                       transformType, lanname);
   13658             : 
   13659          86 :     if (!transform->trffromsql && !transform->trftosql)
   13660           0 :         pg_log_warning("bogus transform definition, at least one of trffromsql and trftosql should be nonzero");
   13661             : 
   13662          86 :     if (transform->trffromsql)
   13663             :     {
   13664          86 :         if (fromsqlFuncInfo)
   13665             :         {
   13666          86 :             char       *fsig = format_function_signature(fout, fromsqlFuncInfo, true);
   13667             : 
   13668             :             /*
   13669             :              * Always qualify the function name (format_function_signature
   13670             :              * won't qualify it).
   13671             :              */
   13672          86 :             appendPQExpBuffer(defqry, "FROM SQL WITH FUNCTION %s.%s",
   13673          86 :                               fmtId(fromsqlFuncInfo->dobj.namespace->dobj.name), fsig);
   13674          86 :             free(fsig);
   13675             :         }
   13676             :         else
   13677           0 :             pg_log_warning("bogus value in pg_transform.trffromsql field");
   13678             :     }
   13679             : 
   13680          86 :     if (transform->trftosql)
   13681             :     {
   13682          86 :         if (transform->trffromsql)
   13683          86 :             appendPQExpBufferStr(defqry, ", ");
   13684             : 
   13685          86 :         if (tosqlFuncInfo)
   13686             :         {
   13687          86 :             char       *fsig = format_function_signature(fout, tosqlFuncInfo, true);
   13688             : 
   13689             :             /*
   13690             :              * Always qualify the function name (format_function_signature
   13691             :              * won't qualify it).
   13692             :              */
   13693          86 :             appendPQExpBuffer(defqry, "TO SQL WITH FUNCTION %s.%s",
   13694          86 :                               fmtId(tosqlFuncInfo->dobj.namespace->dobj.name), fsig);
   13695          86 :             free(fsig);
   13696             :         }
   13697             :         else
   13698           0 :             pg_log_warning("bogus value in pg_transform.trftosql field");
   13699             :     }
   13700             : 
   13701          86 :     appendPQExpBufferStr(defqry, ");\n");
   13702             : 
   13703          86 :     appendPQExpBuffer(labelq, "TRANSFORM FOR %s LANGUAGE %s",
   13704             :                       transformType, lanname);
   13705             : 
   13706          86 :     appendPQExpBuffer(transformargs, "FOR %s LANGUAGE %s",
   13707             :                       transformType, lanname);
   13708             : 
   13709          86 :     if (dopt->binary_upgrade)
   13710           4 :         binary_upgrade_extension_member(defqry, &transform->dobj,
   13711           4 :                                         "TRANSFORM", transformargs->data, NULL);
   13712             : 
   13713          86 :     if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
   13714          86 :         ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
   13715          86 :                      ARCHIVE_OPTS(.tag = labelq->data,
   13716             :                                   .description = "TRANSFORM",
   13717             :                                   .section = SECTION_PRE_DATA,
   13718             :                                   .createStmt = defqry->data,
   13719             :                                   .dropStmt = delqry->data,
   13720             :                                   .deps = transform->dobj.dependencies,
   13721             :                                   .nDeps = transform->dobj.nDeps));
   13722             : 
   13723             :     /* Dump Transform Comments */
   13724          86 :     if (transform->dobj.dump & DUMP_COMPONENT_COMMENT)
   13725           0 :         dumpComment(fout, "TRANSFORM", transformargs->data,
   13726             :                     NULL, "",
   13727             :                     transform->dobj.catId, 0, transform->dobj.dumpId);
   13728             : 
   13729          86 :     free(lanname);
   13730          86 :     destroyPQExpBuffer(defqry);
   13731          86 :     destroyPQExpBuffer(delqry);
   13732          86 :     destroyPQExpBuffer(labelq);
   13733          86 :     destroyPQExpBuffer(transformargs);
   13734             : }
   13735             : 
   13736             : 
   13737             : /*
   13738             :  * dumpOpr
   13739             :  *    write out a single operator definition
   13740             :  */
   13741             : static void
   13742        5098 : dumpOpr(Archive *fout, const OprInfo *oprinfo)
   13743             : {
   13744        5098 :     DumpOptions *dopt = fout->dopt;
   13745             :     PQExpBuffer query;
   13746             :     PQExpBuffer q;
   13747             :     PQExpBuffer delq;
   13748             :     PQExpBuffer oprid;
   13749             :     PQExpBuffer details;
   13750             :     PGresult   *res;
   13751             :     int         i_oprkind;
   13752             :     int         i_oprcode;
   13753             :     int         i_oprleft;
   13754             :     int         i_oprright;
   13755             :     int         i_oprcom;
   13756             :     int         i_oprnegate;
   13757             :     int         i_oprrest;
   13758             :     int         i_oprjoin;
   13759             :     int         i_oprcanmerge;
   13760             :     int         i_oprcanhash;
   13761             :     char       *oprkind;
   13762             :     char       *oprcode;
   13763             :     char       *oprleft;
   13764             :     char       *oprright;
   13765             :     char       *oprcom;
   13766             :     char       *oprnegate;
   13767             :     char       *oprrest;
   13768             :     char       *oprjoin;
   13769             :     char       *oprcanmerge;
   13770             :     char       *oprcanhash;
   13771             :     char       *oprregproc;
   13772             :     char       *oprref;
   13773             : 
   13774             :     /* Do nothing if not dumping schema */
   13775        5098 :     if (!dopt->dumpSchema)
   13776          12 :         return;
   13777             : 
   13778             :     /*
   13779             :      * some operators are invalid because they were the result of user
   13780             :      * defining operators before commutators exist
   13781             :      */
   13782        5086 :     if (!OidIsValid(oprinfo->oprcode))
   13783          44 :         return;
   13784             : 
   13785        5042 :     query = createPQExpBuffer();
   13786        5042 :     q = createPQExpBuffer();
   13787        5042 :     delq = createPQExpBuffer();
   13788        5042 :     oprid = createPQExpBuffer();
   13789        5042 :     details = createPQExpBuffer();
   13790             : 
   13791        5042 :     if (!fout->is_prepared[PREPQUERY_DUMPOPR])
   13792             :     {
   13793             :         /* Set up query for operator-specific details */
   13794          94 :         appendPQExpBufferStr(query,
   13795             :                              "PREPARE dumpOpr(pg_catalog.oid) AS\n"
   13796             :                              "SELECT oprkind, "
   13797             :                              "oprcode::pg_catalog.regprocedure, "
   13798             :                              "oprleft::pg_catalog.regtype, "
   13799             :                              "oprright::pg_catalog.regtype, "
   13800             :                              "oprcom, "
   13801             :                              "oprnegate, "
   13802             :                              "oprrest::pg_catalog.regprocedure, "
   13803             :                              "oprjoin::pg_catalog.regprocedure, "
   13804             :                              "oprcanmerge, oprcanhash "
   13805             :                              "FROM pg_catalog.pg_operator "
   13806             :                              "WHERE oid = $1");
   13807             : 
   13808          94 :         ExecuteSqlStatement(fout, query->data);
   13809             : 
   13810          94 :         fout->is_prepared[PREPQUERY_DUMPOPR] = true;
   13811             :     }
   13812             : 
   13813        5042 :     printfPQExpBuffer(query,
   13814             :                       "EXECUTE dumpOpr('%u')",
   13815             :                       oprinfo->dobj.catId.oid);
   13816             : 
   13817        5042 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   13818             : 
   13819        5042 :     i_oprkind = PQfnumber(res, "oprkind");
   13820        5042 :     i_oprcode = PQfnumber(res, "oprcode");
   13821        5042 :     i_oprleft = PQfnumber(res, "oprleft");
   13822        5042 :     i_oprright = PQfnumber(res, "oprright");
   13823        5042 :     i_oprcom = PQfnumber(res, "oprcom");
   13824        5042 :     i_oprnegate = PQfnumber(res, "oprnegate");
   13825        5042 :     i_oprrest = PQfnumber(res, "oprrest");
   13826        5042 :     i_oprjoin = PQfnumber(res, "oprjoin");
   13827        5042 :     i_oprcanmerge = PQfnumber(res, "oprcanmerge");
   13828        5042 :     i_oprcanhash = PQfnumber(res, "oprcanhash");
   13829             : 
   13830        5042 :     oprkind = PQgetvalue(res, 0, i_oprkind);
   13831        5042 :     oprcode = PQgetvalue(res, 0, i_oprcode);
   13832        5042 :     oprleft = PQgetvalue(res, 0, i_oprleft);
   13833        5042 :     oprright = PQgetvalue(res, 0, i_oprright);
   13834        5042 :     oprcom = PQgetvalue(res, 0, i_oprcom);
   13835        5042 :     oprnegate = PQgetvalue(res, 0, i_oprnegate);
   13836        5042 :     oprrest = PQgetvalue(res, 0, i_oprrest);
   13837        5042 :     oprjoin = PQgetvalue(res, 0, i_oprjoin);
   13838        5042 :     oprcanmerge = PQgetvalue(res, 0, i_oprcanmerge);
   13839        5042 :     oprcanhash = PQgetvalue(res, 0, i_oprcanhash);
   13840             : 
   13841             :     /* In PG14 upwards postfix operator support does not exist anymore. */
   13842        5042 :     if (strcmp(oprkind, "r") == 0)
   13843           0 :         pg_log_warning("postfix operators are not supported anymore (operator \"%s\")",
   13844             :                        oprcode);
   13845             : 
   13846        5042 :     oprregproc = convertRegProcReference(oprcode);
   13847        5042 :     if (oprregproc)
   13848             :     {
   13849        5042 :         appendPQExpBuffer(details, "    FUNCTION = %s", oprregproc);
   13850        5042 :         free(oprregproc);
   13851             :     }
   13852             : 
   13853        5042 :     appendPQExpBuffer(oprid, "%s (",
   13854             :                       oprinfo->dobj.name);
   13855             : 
   13856             :     /*
   13857             :      * right unary means there's a left arg and left unary means there's a
   13858             :      * right arg.  (Although the "r" case is dead code for PG14 and later,
   13859             :      * continue to support it in case we're dumping from an old server.)
   13860             :      */
   13861        5042 :     if (strcmp(oprkind, "r") == 0 ||
   13862        5042 :         strcmp(oprkind, "b") == 0)
   13863             :     {
   13864        4732 :         appendPQExpBuffer(details, ",\n    LEFTARG = %s", oprleft);
   13865        4732 :         appendPQExpBufferStr(oprid, oprleft);
   13866             :     }
   13867             :     else
   13868         310 :         appendPQExpBufferStr(oprid, "NONE");
   13869             : 
   13870        5042 :     if (strcmp(oprkind, "l") == 0 ||
   13871        4732 :         strcmp(oprkind, "b") == 0)
   13872             :     {
   13873        5042 :         appendPQExpBuffer(details, ",\n    RIGHTARG = %s", oprright);
   13874        5042 :         appendPQExpBuffer(oprid, ", %s)", oprright);
   13875             :     }
   13876             :     else
   13877           0 :         appendPQExpBufferStr(oprid, ", NONE)");
   13878             : 
   13879        5042 :     oprref = getFormattedOperatorName(oprcom);
   13880        5042 :     if (oprref)
   13881             :     {
   13882        3346 :         appendPQExpBuffer(details, ",\n    COMMUTATOR = %s", oprref);
   13883        3346 :         free(oprref);
   13884             :     }
   13885             : 
   13886        5042 :     oprref = getFormattedOperatorName(oprnegate);
   13887        5042 :     if (oprref)
   13888             :     {
   13889        2332 :         appendPQExpBuffer(details, ",\n    NEGATOR = %s", oprref);
   13890        2332 :         free(oprref);
   13891             :     }
   13892             : 
   13893        5042 :     if (strcmp(oprcanmerge, "t") == 0)
   13894         394 :         appendPQExpBufferStr(details, ",\n    MERGES");
   13895             : 
   13896        5042 :     if (strcmp(oprcanhash, "t") == 0)
   13897         276 :         appendPQExpBufferStr(details, ",\n    HASHES");
   13898             : 
   13899        5042 :     oprregproc = convertRegProcReference(oprrest);
   13900        5042 :     if (oprregproc)
   13901             :     {
   13902        3052 :         appendPQExpBuffer(details, ",\n    RESTRICT = %s", oprregproc);
   13903        3052 :         free(oprregproc);
   13904             :     }
   13905             : 
   13906        5042 :     oprregproc = convertRegProcReference(oprjoin);
   13907        5042 :     if (oprregproc)
   13908             :     {
   13909        3052 :         appendPQExpBuffer(details, ",\n    JOIN = %s", oprregproc);
   13910        3052 :         free(oprregproc);
   13911             :     }
   13912             : 
   13913        5042 :     appendPQExpBuffer(delq, "DROP OPERATOR %s.%s;\n",
   13914        5042 :                       fmtId(oprinfo->dobj.namespace->dobj.name),
   13915             :                       oprid->data);
   13916             : 
   13917        5042 :     appendPQExpBuffer(q, "CREATE OPERATOR %s.%s (\n%s\n);\n",
   13918        5042 :                       fmtId(oprinfo->dobj.namespace->dobj.name),
   13919             :                       oprinfo->dobj.name, details->data);
   13920             : 
   13921        5042 :     if (dopt->binary_upgrade)
   13922          24 :         binary_upgrade_extension_member(q, &oprinfo->dobj,
   13923          24 :                                         "OPERATOR", oprid->data,
   13924          24 :                                         oprinfo->dobj.namespace->dobj.name);
   13925             : 
   13926        5042 :     if (oprinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   13927        5042 :         ArchiveEntry(fout, oprinfo->dobj.catId, oprinfo->dobj.dumpId,
   13928        5042 :                      ARCHIVE_OPTS(.tag = oprinfo->dobj.name,
   13929             :                                   .namespace = oprinfo->dobj.namespace->dobj.name,
   13930             :                                   .owner = oprinfo->rolname,
   13931             :                                   .description = "OPERATOR",
   13932             :                                   .section = SECTION_PRE_DATA,
   13933             :                                   .createStmt = q->data,
   13934             :                                   .dropStmt = delq->data));
   13935             : 
   13936             :     /* Dump Operator Comments */
   13937        5042 :     if (oprinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   13938        4794 :         dumpComment(fout, "OPERATOR", oprid->data,
   13939        4794 :                     oprinfo->dobj.namespace->dobj.name, oprinfo->rolname,
   13940             :                     oprinfo->dobj.catId, 0, oprinfo->dobj.dumpId);
   13941             : 
   13942        5042 :     PQclear(res);
   13943             : 
   13944        5042 :     destroyPQExpBuffer(query);
   13945        5042 :     destroyPQExpBuffer(q);
   13946        5042 :     destroyPQExpBuffer(delq);
   13947        5042 :     destroyPQExpBuffer(oprid);
   13948        5042 :     destroyPQExpBuffer(details);
   13949             : }
   13950             : 
   13951             : /*
   13952             :  * Convert a function reference obtained from pg_operator
   13953             :  *
   13954             :  * Returns allocated string of what to print, or NULL if function references
   13955             :  * is InvalidOid. Returned string is expected to be free'd by the caller.
   13956             :  *
   13957             :  * The input is a REGPROCEDURE display; we have to strip the argument-types
   13958             :  * part.
   13959             :  */
   13960             : static char *
   13961       15126 : convertRegProcReference(const char *proc)
   13962             : {
   13963             :     char       *name;
   13964             :     char       *paren;
   13965             :     bool        inquote;
   13966             : 
   13967             :     /* In all cases "-" means a null reference */
   13968       15126 :     if (strcmp(proc, "-") == 0)
   13969        3980 :         return NULL;
   13970             : 
   13971       11146 :     name = pg_strdup(proc);
   13972             :     /* find non-double-quoted left paren */
   13973       11146 :     inquote = false;
   13974      134312 :     for (paren = name; *paren; paren++)
   13975             :     {
   13976      134312 :         if (*paren == '(' && !inquote)
   13977             :         {
   13978       11146 :             *paren = '\0';
   13979       11146 :             break;
   13980             :         }
   13981      123166 :         if (*paren == '"')
   13982         100 :             inquote = !inquote;
   13983             :     }
   13984       11146 :     return name;
   13985             : }
   13986             : 
   13987             : /*
   13988             :  * getFormattedOperatorName - retrieve the operator name for the
   13989             :  * given operator OID (presented in string form).
   13990             :  *
   13991             :  * Returns an allocated string, or NULL if the given OID is invalid.
   13992             :  * Caller is responsible for free'ing result string.
   13993             :  *
   13994             :  * What we produce has the format "OPERATOR(schema.oprname)".  This is only
   13995             :  * useful in commands where the operator's argument types can be inferred from
   13996             :  * context.  We always schema-qualify the name, though.  The predecessor to
   13997             :  * this code tried to skip the schema qualification if possible, but that led
   13998             :  * to wrong results in corner cases, such as if an operator and its negator
   13999             :  * are in different schemas.
   14000             :  */
   14001             : static char *
   14002       10944 : getFormattedOperatorName(const char *oproid)
   14003             : {
   14004             :     OprInfo    *oprInfo;
   14005             : 
   14006             :     /* In all cases "0" means a null reference */
   14007       10944 :     if (strcmp(oproid, "0") == 0)
   14008        5266 :         return NULL;
   14009             : 
   14010        5678 :     oprInfo = findOprByOid(atooid(oproid));
   14011        5678 :     if (oprInfo == NULL)
   14012             :     {
   14013           0 :         pg_log_warning("could not find operator with OID %s",
   14014             :                        oproid);
   14015           0 :         return NULL;
   14016             :     }
   14017             : 
   14018        5678 :     return psprintf("OPERATOR(%s.%s)",
   14019        5678 :                     fmtId(oprInfo->dobj.namespace->dobj.name),
   14020             :                     oprInfo->dobj.name);
   14021             : }
   14022             : 
   14023             : /*
   14024             :  * Convert a function OID obtained from pg_ts_parser or pg_ts_template
   14025             :  *
   14026             :  * It is sufficient to use REGPROC rather than REGPROCEDURE, since the
   14027             :  * argument lists of these functions are predetermined.  Note that the
   14028             :  * caller should ensure we are in the proper schema, because the results
   14029             :  * are search path dependent!
   14030             :  */
   14031             : static char *
   14032         450 : convertTSFunction(Archive *fout, Oid funcOid)
   14033             : {
   14034             :     char       *result;
   14035             :     char        query[128];
   14036             :     PGresult   *res;
   14037             : 
   14038         450 :     snprintf(query, sizeof(query),
   14039             :              "SELECT '%u'::pg_catalog.regproc", funcOid);
   14040         450 :     res = ExecuteSqlQueryForSingleRow(fout, query);
   14041             : 
   14042         450 :     result = pg_strdup(PQgetvalue(res, 0, 0));
   14043             : 
   14044         450 :     PQclear(res);
   14045             : 
   14046         450 :     return result;
   14047             : }
   14048             : 
   14049             : /*
   14050             :  * dumpAccessMethod
   14051             :  *    write out a single access method definition
   14052             :  */
   14053             : static void
   14054         182 : dumpAccessMethod(Archive *fout, const AccessMethodInfo *aminfo)
   14055             : {
   14056         182 :     DumpOptions *dopt = fout->dopt;
   14057             :     PQExpBuffer q;
   14058             :     PQExpBuffer delq;
   14059             :     char       *qamname;
   14060             : 
   14061             :     /* Do nothing if not dumping schema */
   14062         182 :     if (!dopt->dumpSchema)
   14063          24 :         return;
   14064             : 
   14065         158 :     q = createPQExpBuffer();
   14066         158 :     delq = createPQExpBuffer();
   14067             : 
   14068         158 :     qamname = pg_strdup(fmtId(aminfo->dobj.name));
   14069             : 
   14070         158 :     appendPQExpBuffer(q, "CREATE ACCESS METHOD %s ", qamname);
   14071             : 
   14072         158 :     switch (aminfo->amtype)
   14073             :     {
   14074          72 :         case AMTYPE_INDEX:
   14075          72 :             appendPQExpBufferStr(q, "TYPE INDEX ");
   14076          72 :             break;
   14077          86 :         case AMTYPE_TABLE:
   14078          86 :             appendPQExpBufferStr(q, "TYPE TABLE ");
   14079          86 :             break;
   14080           0 :         default:
   14081           0 :             pg_log_warning("invalid type \"%c\" of access method \"%s\"",
   14082             :                            aminfo->amtype, qamname);
   14083           0 :             destroyPQExpBuffer(q);
   14084           0 :             destroyPQExpBuffer(delq);
   14085           0 :             free(qamname);
   14086           0 :             return;
   14087             :     }
   14088             : 
   14089         158 :     appendPQExpBuffer(q, "HANDLER %s;\n", aminfo->amhandler);
   14090             : 
   14091         158 :     appendPQExpBuffer(delq, "DROP ACCESS METHOD %s;\n",
   14092             :                       qamname);
   14093             : 
   14094         158 :     if (dopt->binary_upgrade)
   14095           8 :         binary_upgrade_extension_member(q, &aminfo->dobj,
   14096             :                                         "ACCESS METHOD", qamname, NULL);
   14097             : 
   14098         158 :     if (aminfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   14099         158 :         ArchiveEntry(fout, aminfo->dobj.catId, aminfo->dobj.dumpId,
   14100         158 :                      ARCHIVE_OPTS(.tag = aminfo->dobj.name,
   14101             :                                   .description = "ACCESS METHOD",
   14102             :                                   .section = SECTION_PRE_DATA,
   14103             :                                   .createStmt = q->data,
   14104             :                                   .dropStmt = delq->data));
   14105             : 
   14106             :     /* Dump Access Method Comments */
   14107         158 :     if (aminfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   14108           0 :         dumpComment(fout, "ACCESS METHOD", qamname,
   14109             :                     NULL, "",
   14110             :                     aminfo->dobj.catId, 0, aminfo->dobj.dumpId);
   14111             : 
   14112         158 :     destroyPQExpBuffer(q);
   14113         158 :     destroyPQExpBuffer(delq);
   14114         158 :     free(qamname);
   14115             : }
   14116             : 
   14117             : /*
   14118             :  * dumpOpclass
   14119             :  *    write out a single operator class definition
   14120             :  */
   14121             : static void
   14122        1362 : dumpOpclass(Archive *fout, const OpclassInfo *opcinfo)
   14123             : {
   14124        1362 :     DumpOptions *dopt = fout->dopt;
   14125             :     PQExpBuffer query;
   14126             :     PQExpBuffer q;
   14127             :     PQExpBuffer delq;
   14128             :     PQExpBuffer nameusing;
   14129             :     PGresult   *res;
   14130             :     int         ntups;
   14131             :     int         i_opcintype;
   14132             :     int         i_opckeytype;
   14133             :     int         i_opcdefault;
   14134             :     int         i_opcfamily;
   14135             :     int         i_opcfamilyname;
   14136             :     int         i_opcfamilynsp;
   14137             :     int         i_amname;
   14138             :     int         i_amopstrategy;
   14139             :     int         i_amopopr;
   14140             :     int         i_sortfamily;
   14141             :     int         i_sortfamilynsp;
   14142             :     int         i_amprocnum;
   14143             :     int         i_amproc;
   14144             :     int         i_amproclefttype;
   14145             :     int         i_amprocrighttype;
   14146             :     char       *opcintype;
   14147             :     char       *opckeytype;
   14148             :     char       *opcdefault;
   14149             :     char       *opcfamily;
   14150             :     char       *opcfamilyname;
   14151             :     char       *opcfamilynsp;
   14152             :     char       *amname;
   14153             :     char       *amopstrategy;
   14154             :     char       *amopopr;
   14155             :     char       *sortfamily;
   14156             :     char       *sortfamilynsp;
   14157             :     char       *amprocnum;
   14158             :     char       *amproc;
   14159             :     char       *amproclefttype;
   14160             :     char       *amprocrighttype;
   14161             :     bool        needComma;
   14162             :     int         i;
   14163             : 
   14164             :     /* Do nothing if not dumping schema */
   14165        1362 :     if (!dopt->dumpSchema)
   14166          36 :         return;
   14167             : 
   14168        1326 :     query = createPQExpBuffer();
   14169        1326 :     q = createPQExpBuffer();
   14170        1326 :     delq = createPQExpBuffer();
   14171        1326 :     nameusing = createPQExpBuffer();
   14172             : 
   14173             :     /* Get additional fields from the pg_opclass row */
   14174        1326 :     appendPQExpBuffer(query, "SELECT opcintype::pg_catalog.regtype, "
   14175             :                       "opckeytype::pg_catalog.regtype, "
   14176             :                       "opcdefault, opcfamily, "
   14177             :                       "opfname AS opcfamilyname, "
   14178             :                       "nspname AS opcfamilynsp, "
   14179             :                       "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opcmethod) AS amname "
   14180             :                       "FROM pg_catalog.pg_opclass c "
   14181             :                       "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = opcfamily "
   14182             :                       "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
   14183             :                       "WHERE c.oid = '%u'::pg_catalog.oid",
   14184             :                       opcinfo->dobj.catId.oid);
   14185             : 
   14186        1326 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   14187             : 
   14188        1326 :     i_opcintype = PQfnumber(res, "opcintype");
   14189        1326 :     i_opckeytype = PQfnumber(res, "opckeytype");
   14190        1326 :     i_opcdefault = PQfnumber(res, "opcdefault");
   14191        1326 :     i_opcfamily = PQfnumber(res, "opcfamily");
   14192        1326 :     i_opcfamilyname = PQfnumber(res, "opcfamilyname");
   14193        1326 :     i_opcfamilynsp = PQfnumber(res, "opcfamilynsp");
   14194        1326 :     i_amname = PQfnumber(res, "amname");
   14195             : 
   14196             :     /* opcintype may still be needed after we PQclear res */
   14197        1326 :     opcintype = pg_strdup(PQgetvalue(res, 0, i_opcintype));
   14198        1326 :     opckeytype = PQgetvalue(res, 0, i_opckeytype);
   14199        1326 :     opcdefault = PQgetvalue(res, 0, i_opcdefault);
   14200             :     /* opcfamily will still be needed after we PQclear res */
   14201        1326 :     opcfamily = pg_strdup(PQgetvalue(res, 0, i_opcfamily));
   14202        1326 :     opcfamilyname = PQgetvalue(res, 0, i_opcfamilyname);
   14203        1326 :     opcfamilynsp = PQgetvalue(res, 0, i_opcfamilynsp);
   14204             :     /* amname will still be needed after we PQclear res */
   14205        1326 :     amname = pg_strdup(PQgetvalue(res, 0, i_amname));
   14206             : 
   14207        1326 :     appendPQExpBuffer(delq, "DROP OPERATOR CLASS %s",
   14208        1326 :                       fmtQualifiedDumpable(opcinfo));
   14209        1326 :     appendPQExpBuffer(delq, " USING %s;\n",
   14210             :                       fmtId(amname));
   14211             : 
   14212             :     /* Build the fixed portion of the CREATE command */
   14213        1326 :     appendPQExpBuffer(q, "CREATE OPERATOR CLASS %s\n    ",
   14214        1326 :                       fmtQualifiedDumpable(opcinfo));
   14215        1326 :     if (strcmp(opcdefault, "t") == 0)
   14216         714 :         appendPQExpBufferStr(q, "DEFAULT ");
   14217        1326 :     appendPQExpBuffer(q, "FOR TYPE %s USING %s",
   14218             :                       opcintype,
   14219             :                       fmtId(amname));
   14220        1326 :     if (strlen(opcfamilyname) > 0)
   14221             :     {
   14222        1326 :         appendPQExpBufferStr(q, " FAMILY ");
   14223        1326 :         appendPQExpBuffer(q, "%s.", fmtId(opcfamilynsp));
   14224        1326 :         appendPQExpBufferStr(q, fmtId(opcfamilyname));
   14225             :     }
   14226        1326 :     appendPQExpBufferStr(q, " AS\n    ");
   14227             : 
   14228        1326 :     needComma = false;
   14229             : 
   14230        1326 :     if (strcmp(opckeytype, "-") != 0)
   14231             :     {
   14232         504 :         appendPQExpBuffer(q, "STORAGE %s",
   14233             :                           opckeytype);
   14234         504 :         needComma = true;
   14235             :     }
   14236             : 
   14237        1326 :     PQclear(res);
   14238             : 
   14239             :     /*
   14240             :      * Now fetch and print the OPERATOR entries (pg_amop rows).
   14241             :      *
   14242             :      * Print only those opfamily members that are tied to the opclass by
   14243             :      * pg_depend entries.
   14244             :      */
   14245        1326 :     resetPQExpBuffer(query);
   14246        1326 :     appendPQExpBuffer(query, "SELECT amopstrategy, "
   14247             :                       "amopopr::pg_catalog.regoperator, "
   14248             :                       "opfname AS sortfamily, "
   14249             :                       "nspname AS sortfamilynsp "
   14250             :                       "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
   14251             :                       "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
   14252             :                       "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
   14253             :                       "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
   14254             :                       "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
   14255             :                       "AND refobjid = '%u'::pg_catalog.oid "
   14256             :                       "AND amopfamily = '%s'::pg_catalog.oid "
   14257             :                       "ORDER BY amopstrategy",
   14258             :                       opcinfo->dobj.catId.oid,
   14259             :                       opcfamily);
   14260             : 
   14261        1326 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   14262             : 
   14263        1326 :     ntups = PQntuples(res);
   14264             : 
   14265        1326 :     i_amopstrategy = PQfnumber(res, "amopstrategy");
   14266        1326 :     i_amopopr = PQfnumber(res, "amopopr");
   14267        1326 :     i_sortfamily = PQfnumber(res, "sortfamily");
   14268        1326 :     i_sortfamilynsp = PQfnumber(res, "sortfamilynsp");
   14269             : 
   14270        1790 :     for (i = 0; i < ntups; i++)
   14271             :     {
   14272         464 :         amopstrategy = PQgetvalue(res, i, i_amopstrategy);
   14273         464 :         amopopr = PQgetvalue(res, i, i_amopopr);
   14274         464 :         sortfamily = PQgetvalue(res, i, i_sortfamily);
   14275         464 :         sortfamilynsp = PQgetvalue(res, i, i_sortfamilynsp);
   14276             : 
   14277         464 :         if (needComma)
   14278         288 :             appendPQExpBufferStr(q, " ,\n    ");
   14279             : 
   14280         464 :         appendPQExpBuffer(q, "OPERATOR %s %s",
   14281             :                           amopstrategy, amopopr);
   14282             : 
   14283         464 :         if (strlen(sortfamily) > 0)
   14284             :         {
   14285           0 :             appendPQExpBufferStr(q, " FOR ORDER BY ");
   14286           0 :             appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
   14287           0 :             appendPQExpBufferStr(q, fmtId(sortfamily));
   14288             :         }
   14289             : 
   14290         464 :         needComma = true;
   14291             :     }
   14292             : 
   14293        1326 :     PQclear(res);
   14294             : 
   14295             :     /*
   14296             :      * Now fetch and print the FUNCTION entries (pg_amproc rows).
   14297             :      *
   14298             :      * Print only those opfamily members that are tied to the opclass by
   14299             :      * pg_depend entries.
   14300             :      *
   14301             :      * We print the amproclefttype/amprocrighttype even though in most cases
   14302             :      * the backend could deduce the right values, because of the corner case
   14303             :      * of a btree sort support function for a cross-type comparison.
   14304             :      */
   14305        1326 :     resetPQExpBuffer(query);
   14306             : 
   14307        1326 :     appendPQExpBuffer(query, "SELECT amprocnum, "
   14308             :                       "amproc::pg_catalog.regprocedure, "
   14309             :                       "amproclefttype::pg_catalog.regtype, "
   14310             :                       "amprocrighttype::pg_catalog.regtype "
   14311             :                       "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
   14312             :                       "WHERE refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass "
   14313             :                       "AND refobjid = '%u'::pg_catalog.oid "
   14314             :                       "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
   14315             :                       "AND objid = ap.oid "
   14316             :                       "ORDER BY amprocnum",
   14317             :                       opcinfo->dobj.catId.oid);
   14318             : 
   14319        1326 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   14320             : 
   14321        1326 :     ntups = PQntuples(res);
   14322             : 
   14323        1326 :     i_amprocnum = PQfnumber(res, "amprocnum");
   14324        1326 :     i_amproc = PQfnumber(res, "amproc");
   14325        1326 :     i_amproclefttype = PQfnumber(res, "amproclefttype");
   14326        1326 :     i_amprocrighttype = PQfnumber(res, "amprocrighttype");
   14327             : 
   14328        1398 :     for (i = 0; i < ntups; i++)
   14329             :     {
   14330          72 :         amprocnum = PQgetvalue(res, i, i_amprocnum);
   14331          72 :         amproc = PQgetvalue(res, i, i_amproc);
   14332          72 :         amproclefttype = PQgetvalue(res, i, i_amproclefttype);
   14333          72 :         amprocrighttype = PQgetvalue(res, i, i_amprocrighttype);
   14334             : 
   14335          72 :         if (needComma)
   14336          72 :             appendPQExpBufferStr(q, " ,\n    ");
   14337             : 
   14338          72 :         appendPQExpBuffer(q, "FUNCTION %s", amprocnum);
   14339             : 
   14340          72 :         if (*amproclefttype && *amprocrighttype)
   14341          72 :             appendPQExpBuffer(q, " (%s, %s)", amproclefttype, amprocrighttype);
   14342             : 
   14343          72 :         appendPQExpBuffer(q, " %s", amproc);
   14344             : 
   14345          72 :         needComma = true;
   14346             :     }
   14347             : 
   14348        1326 :     PQclear(res);
   14349             : 
   14350             :     /*
   14351             :      * If needComma is still false it means we haven't added anything after
   14352             :      * the AS keyword.  To avoid printing broken SQL, append a dummy STORAGE
   14353             :      * clause with the same datatype.  This isn't sanctioned by the
   14354             :      * documentation, but actually DefineOpClass will treat it as a no-op.
   14355             :      */
   14356        1326 :     if (!needComma)
   14357         646 :         appendPQExpBuffer(q, "STORAGE %s", opcintype);
   14358             : 
   14359        1326 :     appendPQExpBufferStr(q, ";\n");
   14360             : 
   14361        1326 :     appendPQExpBufferStr(nameusing, fmtId(opcinfo->dobj.name));
   14362        1326 :     appendPQExpBuffer(nameusing, " USING %s",
   14363             :                       fmtId(amname));
   14364             : 
   14365        1326 :     if (dopt->binary_upgrade)
   14366          12 :         binary_upgrade_extension_member(q, &opcinfo->dobj,
   14367          12 :                                         "OPERATOR CLASS", nameusing->data,
   14368          12 :                                         opcinfo->dobj.namespace->dobj.name);
   14369             : 
   14370        1326 :     if (opcinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   14371        1326 :         ArchiveEntry(fout, opcinfo->dobj.catId, opcinfo->dobj.dumpId,
   14372        1326 :                      ARCHIVE_OPTS(.tag = opcinfo->dobj.name,
   14373             :                                   .namespace = opcinfo->dobj.namespace->dobj.name,
   14374             :                                   .owner = opcinfo->rolname,
   14375             :                                   .description = "OPERATOR CLASS",
   14376             :                                   .section = SECTION_PRE_DATA,
   14377             :                                   .createStmt = q->data,
   14378             :                                   .dropStmt = delq->data));
   14379             : 
   14380             :     /* Dump Operator Class Comments */
   14381        1326 :     if (opcinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   14382           0 :         dumpComment(fout, "OPERATOR CLASS", nameusing->data,
   14383           0 :                     opcinfo->dobj.namespace->dobj.name, opcinfo->rolname,
   14384             :                     opcinfo->dobj.catId, 0, opcinfo->dobj.dumpId);
   14385             : 
   14386        1326 :     free(opcintype);
   14387        1326 :     free(opcfamily);
   14388        1326 :     free(amname);
   14389        1326 :     destroyPQExpBuffer(query);
   14390        1326 :     destroyPQExpBuffer(q);
   14391        1326 :     destroyPQExpBuffer(delq);
   14392        1326 :     destroyPQExpBuffer(nameusing);
   14393             : }
   14394             : 
   14395             : /*
   14396             :  * dumpOpfamily
   14397             :  *    write out a single operator family definition
   14398             :  *
   14399             :  * Note: this also dumps any "loose" operator members that aren't bound to a
   14400             :  * specific opclass within the opfamily.
   14401             :  */
   14402             : static void
   14403        1156 : dumpOpfamily(Archive *fout, const OpfamilyInfo *opfinfo)
   14404             : {
   14405        1156 :     DumpOptions *dopt = fout->dopt;
   14406             :     PQExpBuffer query;
   14407             :     PQExpBuffer q;
   14408             :     PQExpBuffer delq;
   14409             :     PQExpBuffer nameusing;
   14410             :     PGresult   *res;
   14411             :     PGresult   *res_ops;
   14412             :     PGresult   *res_procs;
   14413             :     int         ntups;
   14414             :     int         i_amname;
   14415             :     int         i_amopstrategy;
   14416             :     int         i_amopopr;
   14417             :     int         i_sortfamily;
   14418             :     int         i_sortfamilynsp;
   14419             :     int         i_amprocnum;
   14420             :     int         i_amproc;
   14421             :     int         i_amproclefttype;
   14422             :     int         i_amprocrighttype;
   14423             :     char       *amname;
   14424             :     char       *amopstrategy;
   14425             :     char       *amopopr;
   14426             :     char       *sortfamily;
   14427             :     char       *sortfamilynsp;
   14428             :     char       *amprocnum;
   14429             :     char       *amproc;
   14430             :     char       *amproclefttype;
   14431             :     char       *amprocrighttype;
   14432             :     bool        needComma;
   14433             :     int         i;
   14434             : 
   14435             :     /* Do nothing if not dumping schema */
   14436        1156 :     if (!dopt->dumpSchema)
   14437          24 :         return;
   14438             : 
   14439        1132 :     query = createPQExpBuffer();
   14440        1132 :     q = createPQExpBuffer();
   14441        1132 :     delq = createPQExpBuffer();
   14442        1132 :     nameusing = createPQExpBuffer();
   14443             : 
   14444             :     /*
   14445             :      * Fetch only those opfamily members that are tied directly to the
   14446             :      * opfamily by pg_depend entries.
   14447             :      */
   14448        1132 :     appendPQExpBuffer(query, "SELECT amopstrategy, "
   14449             :                       "amopopr::pg_catalog.regoperator, "
   14450             :                       "opfname AS sortfamily, "
   14451             :                       "nspname AS sortfamilynsp "
   14452             :                       "FROM pg_catalog.pg_amop ao JOIN pg_catalog.pg_depend ON "
   14453             :                       "(classid = 'pg_catalog.pg_amop'::pg_catalog.regclass AND objid = ao.oid) "
   14454             :                       "LEFT JOIN pg_catalog.pg_opfamily f ON f.oid = amopsortfamily "
   14455             :                       "LEFT JOIN pg_catalog.pg_namespace n ON n.oid = opfnamespace "
   14456             :                       "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
   14457             :                       "AND refobjid = '%u'::pg_catalog.oid "
   14458             :                       "AND amopfamily = '%u'::pg_catalog.oid "
   14459             :                       "ORDER BY amopstrategy",
   14460             :                       opfinfo->dobj.catId.oid,
   14461             :                       opfinfo->dobj.catId.oid);
   14462             : 
   14463        1132 :     res_ops = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   14464             : 
   14465        1132 :     resetPQExpBuffer(query);
   14466             : 
   14467        1132 :     appendPQExpBuffer(query, "SELECT amprocnum, "
   14468             :                       "amproc::pg_catalog.regprocedure, "
   14469             :                       "amproclefttype::pg_catalog.regtype, "
   14470             :                       "amprocrighttype::pg_catalog.regtype "
   14471             :                       "FROM pg_catalog.pg_amproc ap, pg_catalog.pg_depend "
   14472             :                       "WHERE refclassid = 'pg_catalog.pg_opfamily'::pg_catalog.regclass "
   14473             :                       "AND refobjid = '%u'::pg_catalog.oid "
   14474             :                       "AND classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass "
   14475             :                       "AND objid = ap.oid "
   14476             :                       "ORDER BY amprocnum",
   14477             :                       opfinfo->dobj.catId.oid);
   14478             : 
   14479        1132 :     res_procs = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   14480             : 
   14481             :     /* Get additional fields from the pg_opfamily row */
   14482        1132 :     resetPQExpBuffer(query);
   14483             : 
   14484        1132 :     appendPQExpBuffer(query, "SELECT "
   14485             :                       "(SELECT amname FROM pg_catalog.pg_am WHERE oid = opfmethod) AS amname "
   14486             :                       "FROM pg_catalog.pg_opfamily "
   14487             :                       "WHERE oid = '%u'::pg_catalog.oid",
   14488             :                       opfinfo->dobj.catId.oid);
   14489             : 
   14490        1132 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   14491             : 
   14492        1132 :     i_amname = PQfnumber(res, "amname");
   14493             : 
   14494             :     /* amname will still be needed after we PQclear res */
   14495        1132 :     amname = pg_strdup(PQgetvalue(res, 0, i_amname));
   14496             : 
   14497        1132 :     appendPQExpBuffer(delq, "DROP OPERATOR FAMILY %s",
   14498        1132 :                       fmtQualifiedDumpable(opfinfo));
   14499        1132 :     appendPQExpBuffer(delq, " USING %s;\n",
   14500             :                       fmtId(amname));
   14501             : 
   14502             :     /* Build the fixed portion of the CREATE command */
   14503        1132 :     appendPQExpBuffer(q, "CREATE OPERATOR FAMILY %s",
   14504        1132 :                       fmtQualifiedDumpable(opfinfo));
   14505        1132 :     appendPQExpBuffer(q, " USING %s;\n",
   14506             :                       fmtId(amname));
   14507             : 
   14508        1132 :     PQclear(res);
   14509             : 
   14510             :     /* Do we need an ALTER to add loose members? */
   14511        1132 :     if (PQntuples(res_ops) > 0 || PQntuples(res_procs) > 0)
   14512             :     {
   14513         120 :         appendPQExpBuffer(q, "ALTER OPERATOR FAMILY %s",
   14514         120 :                           fmtQualifiedDumpable(opfinfo));
   14515         120 :         appendPQExpBuffer(q, " USING %s ADD\n    ",
   14516             :                           fmtId(amname));
   14517             : 
   14518         120 :         needComma = false;
   14519             : 
   14520             :         /*
   14521             :          * Now fetch and print the OPERATOR entries (pg_amop rows).
   14522             :          */
   14523         120 :         ntups = PQntuples(res_ops);
   14524             : 
   14525         120 :         i_amopstrategy = PQfnumber(res_ops, "amopstrategy");
   14526         120 :         i_amopopr = PQfnumber(res_ops, "amopopr");
   14527         120 :         i_sortfamily = PQfnumber(res_ops, "sortfamily");
   14528         120 :         i_sortfamilynsp = PQfnumber(res_ops, "sortfamilynsp");
   14529             : 
   14530         480 :         for (i = 0; i < ntups; i++)
   14531             :         {
   14532         360 :             amopstrategy = PQgetvalue(res_ops, i, i_amopstrategy);
   14533         360 :             amopopr = PQgetvalue(res_ops, i, i_amopopr);
   14534         360 :             sortfamily = PQgetvalue(res_ops, i, i_sortfamily);
   14535         360 :             sortfamilynsp = PQgetvalue(res_ops, i, i_sortfamilynsp);
   14536             : 
   14537         360 :             if (needComma)
   14538         288 :                 appendPQExpBufferStr(q, " ,\n    ");
   14539             : 
   14540         360 :             appendPQExpBuffer(q, "OPERATOR %s %s",
   14541             :                               amopstrategy, amopopr);
   14542             : 
   14543         360 :             if (strlen(sortfamily) > 0)
   14544             :             {
   14545           0 :                 appendPQExpBufferStr(q, " FOR ORDER BY ");
   14546           0 :                 appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
   14547           0 :                 appendPQExpBufferStr(q, fmtId(sortfamily));
   14548             :             }
   14549             : 
   14550         360 :             needComma = true;
   14551             :         }
   14552             : 
   14553             :         /*
   14554             :          * Now fetch and print the FUNCTION entries (pg_amproc rows).
   14555             :          */
   14556         120 :         ntups = PQntuples(res_procs);
   14557             : 
   14558         120 :         i_amprocnum = PQfnumber(res_procs, "amprocnum");
   14559         120 :         i_amproc = PQfnumber(res_procs, "amproc");
   14560         120 :         i_amproclefttype = PQfnumber(res_procs, "amproclefttype");
   14561         120 :         i_amprocrighttype = PQfnumber(res_procs, "amprocrighttype");
   14562             : 
   14563         528 :         for (i = 0; i < ntups; i++)
   14564             :         {
   14565         408 :             amprocnum = PQgetvalue(res_procs, i, i_amprocnum);
   14566         408 :             amproc = PQgetvalue(res_procs, i, i_amproc);
   14567         408 :             amproclefttype = PQgetvalue(res_procs, i, i_amproclefttype);
   14568         408 :             amprocrighttype = PQgetvalue(res_procs, i, i_amprocrighttype);
   14569             : 
   14570         408 :             if (needComma)
   14571         360 :                 appendPQExpBufferStr(q, " ,\n    ");
   14572             : 
   14573         408 :             appendPQExpBuffer(q, "FUNCTION %s (%s, %s) %s",
   14574             :                               amprocnum, amproclefttype, amprocrighttype,
   14575             :                               amproc);
   14576             : 
   14577         408 :             needComma = true;
   14578             :         }
   14579             : 
   14580         120 :         appendPQExpBufferStr(q, ";\n");
   14581             :     }
   14582             : 
   14583        1132 :     appendPQExpBufferStr(nameusing, fmtId(opfinfo->dobj.name));
   14584        1132 :     appendPQExpBuffer(nameusing, " USING %s",
   14585             :                       fmtId(amname));
   14586             : 
   14587        1132 :     if (dopt->binary_upgrade)
   14588          18 :         binary_upgrade_extension_member(q, &opfinfo->dobj,
   14589          18 :                                         "OPERATOR FAMILY", nameusing->data,
   14590          18 :                                         opfinfo->dobj.namespace->dobj.name);
   14591             : 
   14592        1132 :     if (opfinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   14593        1132 :         ArchiveEntry(fout, opfinfo->dobj.catId, opfinfo->dobj.dumpId,
   14594        1132 :                      ARCHIVE_OPTS(.tag = opfinfo->dobj.name,
   14595             :                                   .namespace = opfinfo->dobj.namespace->dobj.name,
   14596             :                                   .owner = opfinfo->rolname,
   14597             :                                   .description = "OPERATOR FAMILY",
   14598             :                                   .section = SECTION_PRE_DATA,
   14599             :                                   .createStmt = q->data,
   14600             :                                   .dropStmt = delq->data));
   14601             : 
   14602             :     /* Dump Operator Family Comments */
   14603        1132 :     if (opfinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   14604           0 :         dumpComment(fout, "OPERATOR FAMILY", nameusing->data,
   14605           0 :                     opfinfo->dobj.namespace->dobj.name, opfinfo->rolname,
   14606             :                     opfinfo->dobj.catId, 0, opfinfo->dobj.dumpId);
   14607             : 
   14608        1132 :     free(amname);
   14609        1132 :     PQclear(res_ops);
   14610        1132 :     PQclear(res_procs);
   14611        1132 :     destroyPQExpBuffer(query);
   14612        1132 :     destroyPQExpBuffer(q);
   14613        1132 :     destroyPQExpBuffer(delq);
   14614        1132 :     destroyPQExpBuffer(nameusing);
   14615             : }
   14616             : 
   14617             : /*
   14618             :  * dumpCollation
   14619             :  *    write out a single collation definition
   14620             :  */
   14621             : static void
   14622        4970 : dumpCollation(Archive *fout, const CollInfo *collinfo)
   14623             : {
   14624        4970 :     DumpOptions *dopt = fout->dopt;
   14625             :     PQExpBuffer query;
   14626             :     PQExpBuffer q;
   14627             :     PQExpBuffer delq;
   14628             :     char       *qcollname;
   14629             :     PGresult   *res;
   14630             :     int         i_collprovider;
   14631             :     int         i_collisdeterministic;
   14632             :     int         i_collcollate;
   14633             :     int         i_collctype;
   14634             :     int         i_colllocale;
   14635             :     int         i_collicurules;
   14636             :     const char *collprovider;
   14637             :     const char *collcollate;
   14638             :     const char *collctype;
   14639             :     const char *colllocale;
   14640             :     const char *collicurules;
   14641             : 
   14642             :     /* Do nothing if not dumping schema */
   14643        4970 :     if (!dopt->dumpSchema)
   14644          24 :         return;
   14645             : 
   14646        4946 :     query = createPQExpBuffer();
   14647        4946 :     q = createPQExpBuffer();
   14648        4946 :     delq = createPQExpBuffer();
   14649             : 
   14650        4946 :     qcollname = pg_strdup(fmtId(collinfo->dobj.name));
   14651             : 
   14652             :     /* Get collation-specific details */
   14653        4946 :     appendPQExpBufferStr(query, "SELECT ");
   14654             : 
   14655        4946 :     if (fout->remoteVersion >= 100000)
   14656        4946 :         appendPQExpBufferStr(query,
   14657             :                              "collprovider, "
   14658             :                              "collversion, ");
   14659             :     else
   14660           0 :         appendPQExpBufferStr(query,
   14661             :                              "'c' AS collprovider, "
   14662             :                              "NULL AS collversion, ");
   14663             : 
   14664        4946 :     if (fout->remoteVersion >= 120000)
   14665        4946 :         appendPQExpBufferStr(query,
   14666             :                              "collisdeterministic, ");
   14667             :     else
   14668           0 :         appendPQExpBufferStr(query,
   14669             :                              "true AS collisdeterministic, ");
   14670             : 
   14671        4946 :     if (fout->remoteVersion >= 170000)
   14672        4946 :         appendPQExpBufferStr(query,
   14673             :                              "colllocale, ");
   14674           0 :     else if (fout->remoteVersion >= 150000)
   14675           0 :         appendPQExpBufferStr(query,
   14676             :                              "colliculocale AS colllocale, ");
   14677             :     else
   14678           0 :         appendPQExpBufferStr(query,
   14679             :                              "NULL AS colllocale, ");
   14680             : 
   14681        4946 :     if (fout->remoteVersion >= 160000)
   14682        4946 :         appendPQExpBufferStr(query,
   14683             :                              "collicurules, ");
   14684             :     else
   14685           0 :         appendPQExpBufferStr(query,
   14686             :                              "NULL AS collicurules, ");
   14687             : 
   14688        4946 :     appendPQExpBuffer(query,
   14689             :                       "collcollate, "
   14690             :                       "collctype "
   14691             :                       "FROM pg_catalog.pg_collation c "
   14692             :                       "WHERE c.oid = '%u'::pg_catalog.oid",
   14693             :                       collinfo->dobj.catId.oid);
   14694             : 
   14695        4946 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   14696             : 
   14697        4946 :     i_collprovider = PQfnumber(res, "collprovider");
   14698        4946 :     i_collisdeterministic = PQfnumber(res, "collisdeterministic");
   14699        4946 :     i_collcollate = PQfnumber(res, "collcollate");
   14700        4946 :     i_collctype = PQfnumber(res, "collctype");
   14701        4946 :     i_colllocale = PQfnumber(res, "colllocale");
   14702        4946 :     i_collicurules = PQfnumber(res, "collicurules");
   14703             : 
   14704        4946 :     collprovider = PQgetvalue(res, 0, i_collprovider);
   14705             : 
   14706        4946 :     if (!PQgetisnull(res, 0, i_collcollate))
   14707         100 :         collcollate = PQgetvalue(res, 0, i_collcollate);
   14708             :     else
   14709        4846 :         collcollate = NULL;
   14710             : 
   14711        4946 :     if (!PQgetisnull(res, 0, i_collctype))
   14712         100 :         collctype = PQgetvalue(res, 0, i_collctype);
   14713             :     else
   14714        4846 :         collctype = NULL;
   14715             : 
   14716             :     /*
   14717             :      * Before version 15, collcollate and collctype were of type NAME and
   14718             :      * non-nullable. Treat empty strings as NULL for consistency.
   14719             :      */
   14720        4946 :     if (fout->remoteVersion < 150000)
   14721             :     {
   14722           0 :         if (collcollate[0] == '\0')
   14723           0 :             collcollate = NULL;
   14724           0 :         if (collctype[0] == '\0')
   14725           0 :             collctype = NULL;
   14726             :     }
   14727             : 
   14728        4946 :     if (!PQgetisnull(res, 0, i_colllocale))
   14729        4840 :         colllocale = PQgetvalue(res, 0, i_colllocale);
   14730             :     else
   14731         106 :         colllocale = NULL;
   14732             : 
   14733        4946 :     if (!PQgetisnull(res, 0, i_collicurules))
   14734           0 :         collicurules = PQgetvalue(res, 0, i_collicurules);
   14735             :     else
   14736        4946 :         collicurules = NULL;
   14737             : 
   14738        4946 :     appendPQExpBuffer(delq, "DROP COLLATION %s;\n",
   14739        4946 :                       fmtQualifiedDumpable(collinfo));
   14740             : 
   14741        4946 :     appendPQExpBuffer(q, "CREATE COLLATION %s (",
   14742        4946 :                       fmtQualifiedDumpable(collinfo));
   14743             : 
   14744        4946 :     appendPQExpBufferStr(q, "provider = ");
   14745        4946 :     if (collprovider[0] == 'b')
   14746          50 :         appendPQExpBufferStr(q, "builtin");
   14747        4896 :     else if (collprovider[0] == 'c')
   14748         100 :         appendPQExpBufferStr(q, "libc");
   14749        4796 :     else if (collprovider[0] == 'i')
   14750        4790 :         appendPQExpBufferStr(q, "icu");
   14751           6 :     else if (collprovider[0] == 'd')
   14752             :         /* to allow dumping pg_catalog; not accepted on input */
   14753           6 :         appendPQExpBufferStr(q, "default");
   14754             :     else
   14755           0 :         pg_fatal("unrecognized collation provider: %s",
   14756             :                  collprovider);
   14757             : 
   14758        4946 :     if (strcmp(PQgetvalue(res, 0, i_collisdeterministic), "f") == 0)
   14759           0 :         appendPQExpBufferStr(q, ", deterministic = false");
   14760             : 
   14761        4946 :     if (collprovider[0] == 'd')
   14762             :     {
   14763           6 :         if (collcollate || collctype || colllocale || collicurules)
   14764           0 :             pg_log_warning("invalid collation \"%s\"", qcollname);
   14765             : 
   14766             :         /* no locale -- the default collation cannot be reloaded anyway */
   14767             :     }
   14768        4940 :     else if (collprovider[0] == 'b')
   14769             :     {
   14770          50 :         if (collcollate || collctype || !colllocale || collicurules)
   14771           0 :             pg_log_warning("invalid collation \"%s\"", qcollname);
   14772             : 
   14773          50 :         appendPQExpBufferStr(q, ", locale = ");
   14774          50 :         appendStringLiteralAH(q, colllocale ? colllocale : "",
   14775             :                               fout);
   14776             :     }
   14777        4890 :     else if (collprovider[0] == 'i')
   14778             :     {
   14779        4790 :         if (fout->remoteVersion >= 150000)
   14780             :         {
   14781        4790 :             if (collcollate || collctype || !colllocale)
   14782           0 :                 pg_log_warning("invalid collation \"%s\"", qcollname);
   14783             : 
   14784        4790 :             appendPQExpBufferStr(q, ", locale = ");
   14785        4790 :             appendStringLiteralAH(q, colllocale ? colllocale : "",
   14786             :                                   fout);
   14787             :         }
   14788             :         else
   14789             :         {
   14790           0 :             if (!collcollate || !collctype || colllocale ||
   14791           0 :                 strcmp(collcollate, collctype) != 0)
   14792           0 :                 pg_log_warning("invalid collation \"%s\"", qcollname);
   14793             : 
   14794           0 :             appendPQExpBufferStr(q, ", locale = ");
   14795           0 :             appendStringLiteralAH(q, collcollate ? collcollate : "", fout);
   14796             :         }
   14797             : 
   14798        4790 :         if (collicurules)
   14799             :         {
   14800           0 :             appendPQExpBufferStr(q, ", rules = ");
   14801           0 :             appendStringLiteralAH(q, collicurules ? collicurules : "", fout);
   14802             :         }
   14803             :     }
   14804         100 :     else if (collprovider[0] == 'c')
   14805             :     {
   14806         100 :         if (colllocale || collicurules || !collcollate || !collctype)
   14807           0 :             pg_log_warning("invalid collation \"%s\"", qcollname);
   14808             : 
   14809         100 :         if (collcollate && collctype && strcmp(collcollate, collctype) == 0)
   14810             :         {
   14811         100 :             appendPQExpBufferStr(q, ", locale = ");
   14812         100 :             appendStringLiteralAH(q, collcollate ? collcollate : "", fout);
   14813             :         }
   14814             :         else
   14815             :         {
   14816           0 :             appendPQExpBufferStr(q, ", lc_collate = ");
   14817           0 :             appendStringLiteralAH(q, collcollate ? collcollate : "", fout);
   14818           0 :             appendPQExpBufferStr(q, ", lc_ctype = ");
   14819           0 :             appendStringLiteralAH(q, collctype ? collctype : "", fout);
   14820             :         }
   14821             :     }
   14822             :     else
   14823           0 :         pg_fatal("unrecognized collation provider: %s", collprovider);
   14824             : 
   14825             :     /*
   14826             :      * For binary upgrade, carry over the collation version.  For normal
   14827             :      * dump/restore, omit the version, so that it is computed upon restore.
   14828             :      */
   14829        4946 :     if (dopt->binary_upgrade)
   14830             :     {
   14831             :         int         i_collversion;
   14832             : 
   14833          10 :         i_collversion = PQfnumber(res, "collversion");
   14834          10 :         if (!PQgetisnull(res, 0, i_collversion))
   14835             :         {
   14836           8 :             appendPQExpBufferStr(q, ", version = ");
   14837           8 :             appendStringLiteralAH(q,
   14838             :                                   PQgetvalue(res, 0, i_collversion),
   14839             :                                   fout);
   14840             :         }
   14841             :     }
   14842             : 
   14843        4946 :     appendPQExpBufferStr(q, ");\n");
   14844             : 
   14845        4946 :     if (dopt->binary_upgrade)
   14846          10 :         binary_upgrade_extension_member(q, &collinfo->dobj,
   14847             :                                         "COLLATION", qcollname,
   14848          10 :                                         collinfo->dobj.namespace->dobj.name);
   14849             : 
   14850        4946 :     if (collinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   14851        4946 :         ArchiveEntry(fout, collinfo->dobj.catId, collinfo->dobj.dumpId,
   14852        4946 :                      ARCHIVE_OPTS(.tag = collinfo->dobj.name,
   14853             :                                   .namespace = collinfo->dobj.namespace->dobj.name,
   14854             :                                   .owner = collinfo->rolname,
   14855             :                                   .description = "COLLATION",
   14856             :                                   .section = SECTION_PRE_DATA,
   14857             :                                   .createStmt = q->data,
   14858             :                                   .dropStmt = delq->data));
   14859             : 
   14860             :     /* Dump Collation Comments */
   14861        4946 :     if (collinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   14862        4744 :         dumpComment(fout, "COLLATION", qcollname,
   14863        4744 :                     collinfo->dobj.namespace->dobj.name, collinfo->rolname,
   14864             :                     collinfo->dobj.catId, 0, collinfo->dobj.dumpId);
   14865             : 
   14866        4946 :     PQclear(res);
   14867             : 
   14868        4946 :     destroyPQExpBuffer(query);
   14869        4946 :     destroyPQExpBuffer(q);
   14870        4946 :     destroyPQExpBuffer(delq);
   14871        4946 :     free(qcollname);
   14872             : }
   14873             : 
   14874             : /*
   14875             :  * dumpConversion
   14876             :  *    write out a single conversion definition
   14877             :  */
   14878             : static void
   14879         852 : dumpConversion(Archive *fout, const ConvInfo *convinfo)
   14880             : {
   14881         852 :     DumpOptions *dopt = fout->dopt;
   14882             :     PQExpBuffer query;
   14883             :     PQExpBuffer q;
   14884             :     PQExpBuffer delq;
   14885             :     char       *qconvname;
   14886             :     PGresult   *res;
   14887             :     int         i_conforencoding;
   14888             :     int         i_contoencoding;
   14889             :     int         i_conproc;
   14890             :     int         i_condefault;
   14891             :     const char *conforencoding;
   14892             :     const char *contoencoding;
   14893             :     const char *conproc;
   14894             :     bool        condefault;
   14895             : 
   14896             :     /* Do nothing if not dumping schema */
   14897         852 :     if (!dopt->dumpSchema)
   14898          12 :         return;
   14899             : 
   14900         840 :     query = createPQExpBuffer();
   14901         840 :     q = createPQExpBuffer();
   14902         840 :     delq = createPQExpBuffer();
   14903             : 
   14904         840 :     qconvname = pg_strdup(fmtId(convinfo->dobj.name));
   14905             : 
   14906             :     /* Get conversion-specific details */
   14907         840 :     appendPQExpBuffer(query, "SELECT "
   14908             :                       "pg_catalog.pg_encoding_to_char(conforencoding) AS conforencoding, "
   14909             :                       "pg_catalog.pg_encoding_to_char(contoencoding) AS contoencoding, "
   14910             :                       "conproc, condefault "
   14911             :                       "FROM pg_catalog.pg_conversion c "
   14912             :                       "WHERE c.oid = '%u'::pg_catalog.oid",
   14913             :                       convinfo->dobj.catId.oid);
   14914             : 
   14915         840 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   14916             : 
   14917         840 :     i_conforencoding = PQfnumber(res, "conforencoding");
   14918         840 :     i_contoencoding = PQfnumber(res, "contoencoding");
   14919         840 :     i_conproc = PQfnumber(res, "conproc");
   14920         840 :     i_condefault = PQfnumber(res, "condefault");
   14921             : 
   14922         840 :     conforencoding = PQgetvalue(res, 0, i_conforencoding);
   14923         840 :     contoencoding = PQgetvalue(res, 0, i_contoencoding);
   14924         840 :     conproc = PQgetvalue(res, 0, i_conproc);
   14925         840 :     condefault = (PQgetvalue(res, 0, i_condefault)[0] == 't');
   14926             : 
   14927         840 :     appendPQExpBuffer(delq, "DROP CONVERSION %s;\n",
   14928         840 :                       fmtQualifiedDumpable(convinfo));
   14929             : 
   14930         840 :     appendPQExpBuffer(q, "CREATE %sCONVERSION %s FOR ",
   14931             :                       (condefault) ? "DEFAULT " : "",
   14932         840 :                       fmtQualifiedDumpable(convinfo));
   14933         840 :     appendStringLiteralAH(q, conforencoding, fout);
   14934         840 :     appendPQExpBufferStr(q, " TO ");
   14935         840 :     appendStringLiteralAH(q, contoencoding, fout);
   14936             :     /* regproc output is already sufficiently quoted */
   14937         840 :     appendPQExpBuffer(q, " FROM %s;\n", conproc);
   14938             : 
   14939         840 :     if (dopt->binary_upgrade)
   14940           2 :         binary_upgrade_extension_member(q, &convinfo->dobj,
   14941             :                                         "CONVERSION", qconvname,
   14942           2 :                                         convinfo->dobj.namespace->dobj.name);
   14943             : 
   14944         840 :     if (convinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   14945         840 :         ArchiveEntry(fout, convinfo->dobj.catId, convinfo->dobj.dumpId,
   14946         840 :                      ARCHIVE_OPTS(.tag = convinfo->dobj.name,
   14947             :                                   .namespace = convinfo->dobj.namespace->dobj.name,
   14948             :                                   .owner = convinfo->rolname,
   14949             :                                   .description = "CONVERSION",
   14950             :                                   .section = SECTION_PRE_DATA,
   14951             :                                   .createStmt = q->data,
   14952             :                                   .dropStmt = delq->data));
   14953             : 
   14954             :     /* Dump Conversion Comments */
   14955         840 :     if (convinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   14956         840 :         dumpComment(fout, "CONVERSION", qconvname,
   14957         840 :                     convinfo->dobj.namespace->dobj.name, convinfo->rolname,
   14958             :                     convinfo->dobj.catId, 0, convinfo->dobj.dumpId);
   14959             : 
   14960         840 :     PQclear(res);
   14961             : 
   14962         840 :     destroyPQExpBuffer(query);
   14963         840 :     destroyPQExpBuffer(q);
   14964         840 :     destroyPQExpBuffer(delq);
   14965         840 :     free(qconvname);
   14966             : }
   14967             : 
   14968             : /*
   14969             :  * format_aggregate_signature: generate aggregate name and argument list
   14970             :  *
   14971             :  * The argument type names are qualified if needed.  The aggregate name
   14972             :  * is never qualified.
   14973             :  */
   14974             : static char *
   14975         860 : format_aggregate_signature(const AggInfo *agginfo, Archive *fout, bool honor_quotes)
   14976             : {
   14977             :     PQExpBufferData buf;
   14978             :     int         j;
   14979             : 
   14980         860 :     initPQExpBuffer(&buf);
   14981         860 :     if (honor_quotes)
   14982           0 :         appendPQExpBufferStr(&buf, fmtId(agginfo->aggfn.dobj.name));
   14983             :     else
   14984         860 :         appendPQExpBufferStr(&buf, agginfo->aggfn.dobj.name);
   14985             : 
   14986         860 :     if (agginfo->aggfn.nargs == 0)
   14987         128 :         appendPQExpBufferStr(&buf, "(*)");
   14988             :     else
   14989             :     {
   14990         732 :         appendPQExpBufferChar(&buf, '(');
   14991        1608 :         for (j = 0; j < agginfo->aggfn.nargs; j++)
   14992         876 :             appendPQExpBuffer(&buf, "%s%s",
   14993             :                               (j > 0) ? ", " : "",
   14994             :                               getFormattedTypeName(fout,
   14995         876 :                                                    agginfo->aggfn.argtypes[j],
   14996             :                                                    zeroIsError));
   14997         732 :         appendPQExpBufferChar(&buf, ')');
   14998             :     }
   14999         860 :     return buf.data;
   15000             : }
   15001             : 
   15002             : /*
   15003             :  * dumpAgg
   15004             :  *    write out a single aggregate definition
   15005             :  */
   15006             : static void
   15007         874 : dumpAgg(Archive *fout, const AggInfo *agginfo)
   15008             : {
   15009         874 :     DumpOptions *dopt = fout->dopt;
   15010             :     PQExpBuffer query;
   15011             :     PQExpBuffer q;
   15012             :     PQExpBuffer delq;
   15013             :     PQExpBuffer details;
   15014             :     char       *aggsig;         /* identity signature */
   15015         874 :     char       *aggfullsig = NULL;  /* full signature */
   15016             :     char       *aggsig_tag;
   15017             :     PGresult   *res;
   15018             :     int         i_agginitval;
   15019             :     int         i_aggminitval;
   15020             :     const char *aggtransfn;
   15021             :     const char *aggfinalfn;
   15022             :     const char *aggcombinefn;
   15023             :     const char *aggserialfn;
   15024             :     const char *aggdeserialfn;
   15025             :     const char *aggmtransfn;
   15026             :     const char *aggminvtransfn;
   15027             :     const char *aggmfinalfn;
   15028             :     bool        aggfinalextra;
   15029             :     bool        aggmfinalextra;
   15030             :     char        aggfinalmodify;
   15031             :     char        aggmfinalmodify;
   15032             :     const char *aggsortop;
   15033             :     char       *aggsortconvop;
   15034             :     char        aggkind;
   15035             :     const char *aggtranstype;
   15036             :     const char *aggtransspace;
   15037             :     const char *aggmtranstype;
   15038             :     const char *aggmtransspace;
   15039             :     const char *agginitval;
   15040             :     const char *aggminitval;
   15041             :     const char *proparallel;
   15042             :     char        defaultfinalmodify;
   15043             : 
   15044             :     /* Do nothing if not dumping schema */
   15045         874 :     if (!dopt->dumpSchema)
   15046          14 :         return;
   15047             : 
   15048         860 :     query = createPQExpBuffer();
   15049         860 :     q = createPQExpBuffer();
   15050         860 :     delq = createPQExpBuffer();
   15051         860 :     details = createPQExpBuffer();
   15052             : 
   15053         860 :     if (!fout->is_prepared[PREPQUERY_DUMPAGG])
   15054             :     {
   15055             :         /* Set up query for aggregate-specific details */
   15056         124 :         appendPQExpBufferStr(query,
   15057             :                              "PREPARE dumpAgg(pg_catalog.oid) AS\n");
   15058             : 
   15059         124 :         appendPQExpBufferStr(query,
   15060             :                              "SELECT "
   15061             :                              "aggtransfn,\n"
   15062             :                              "aggfinalfn,\n"
   15063             :                              "aggtranstype::pg_catalog.regtype,\n"
   15064             :                              "agginitval,\n"
   15065             :                              "aggsortop,\n"
   15066             :                              "pg_catalog.pg_get_function_arguments(p.oid) AS funcargs,\n"
   15067             :                              "pg_catalog.pg_get_function_identity_arguments(p.oid) AS funciargs,\n");
   15068             : 
   15069         124 :         if (fout->remoteVersion >= 90400)
   15070         124 :             appendPQExpBufferStr(query,
   15071             :                                  "aggkind,\n"
   15072             :                                  "aggmtransfn,\n"
   15073             :                                  "aggminvtransfn,\n"
   15074             :                                  "aggmfinalfn,\n"
   15075             :                                  "aggmtranstype::pg_catalog.regtype,\n"
   15076             :                                  "aggfinalextra,\n"
   15077             :                                  "aggmfinalextra,\n"
   15078             :                                  "aggtransspace,\n"
   15079             :                                  "aggmtransspace,\n"
   15080             :                                  "aggminitval,\n");
   15081             :         else
   15082           0 :             appendPQExpBufferStr(query,
   15083             :                                  "'n' AS aggkind,\n"
   15084             :                                  "'-' AS aggmtransfn,\n"
   15085             :                                  "'-' AS aggminvtransfn,\n"
   15086             :                                  "'-' AS aggmfinalfn,\n"
   15087             :                                  "0 AS aggmtranstype,\n"
   15088             :                                  "false AS aggfinalextra,\n"
   15089             :                                  "false AS aggmfinalextra,\n"
   15090             :                                  "0 AS aggtransspace,\n"
   15091             :                                  "0 AS aggmtransspace,\n"
   15092             :                                  "NULL AS aggminitval,\n");
   15093             : 
   15094         124 :         if (fout->remoteVersion >= 90600)
   15095         124 :             appendPQExpBufferStr(query,
   15096             :                                  "aggcombinefn,\n"
   15097             :                                  "aggserialfn,\n"
   15098             :                                  "aggdeserialfn,\n"
   15099             :                                  "proparallel,\n");
   15100             :         else
   15101           0 :             appendPQExpBufferStr(query,
   15102             :                                  "'-' AS aggcombinefn,\n"
   15103             :                                  "'-' AS aggserialfn,\n"
   15104             :                                  "'-' AS aggdeserialfn,\n"
   15105             :                                  "'u' AS proparallel,\n");
   15106             : 
   15107         124 :         if (fout->remoteVersion >= 110000)
   15108         124 :             appendPQExpBufferStr(query,
   15109             :                                  "aggfinalmodify,\n"
   15110             :                                  "aggmfinalmodify\n");
   15111             :         else
   15112           0 :             appendPQExpBufferStr(query,
   15113             :                                  "'0' AS aggfinalmodify,\n"
   15114             :                                  "'0' AS aggmfinalmodify\n");
   15115             : 
   15116         124 :         appendPQExpBufferStr(query,
   15117             :                              "FROM pg_catalog.pg_aggregate a, pg_catalog.pg_proc p "
   15118             :                              "WHERE a.aggfnoid = p.oid "
   15119             :                              "AND p.oid = $1");
   15120             : 
   15121         124 :         ExecuteSqlStatement(fout, query->data);
   15122             : 
   15123         124 :         fout->is_prepared[PREPQUERY_DUMPAGG] = true;
   15124             :     }
   15125             : 
   15126         860 :     printfPQExpBuffer(query,
   15127             :                       "EXECUTE dumpAgg('%u')",
   15128             :                       agginfo->aggfn.dobj.catId.oid);
   15129             : 
   15130         860 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   15131             : 
   15132         860 :     i_agginitval = PQfnumber(res, "agginitval");
   15133         860 :     i_aggminitval = PQfnumber(res, "aggminitval");
   15134             : 
   15135         860 :     aggtransfn = PQgetvalue(res, 0, PQfnumber(res, "aggtransfn"));
   15136         860 :     aggfinalfn = PQgetvalue(res, 0, PQfnumber(res, "aggfinalfn"));
   15137         860 :     aggcombinefn = PQgetvalue(res, 0, PQfnumber(res, "aggcombinefn"));
   15138         860 :     aggserialfn = PQgetvalue(res, 0, PQfnumber(res, "aggserialfn"));
   15139         860 :     aggdeserialfn = PQgetvalue(res, 0, PQfnumber(res, "aggdeserialfn"));
   15140         860 :     aggmtransfn = PQgetvalue(res, 0, PQfnumber(res, "aggmtransfn"));
   15141         860 :     aggminvtransfn = PQgetvalue(res, 0, PQfnumber(res, "aggminvtransfn"));
   15142         860 :     aggmfinalfn = PQgetvalue(res, 0, PQfnumber(res, "aggmfinalfn"));
   15143         860 :     aggfinalextra = (PQgetvalue(res, 0, PQfnumber(res, "aggfinalextra"))[0] == 't');
   15144         860 :     aggmfinalextra = (PQgetvalue(res, 0, PQfnumber(res, "aggmfinalextra"))[0] == 't');
   15145         860 :     aggfinalmodify = PQgetvalue(res, 0, PQfnumber(res, "aggfinalmodify"))[0];
   15146         860 :     aggmfinalmodify = PQgetvalue(res, 0, PQfnumber(res, "aggmfinalmodify"))[0];
   15147         860 :     aggsortop = PQgetvalue(res, 0, PQfnumber(res, "aggsortop"));
   15148         860 :     aggkind = PQgetvalue(res, 0, PQfnumber(res, "aggkind"))[0];
   15149         860 :     aggtranstype = PQgetvalue(res, 0, PQfnumber(res, "aggtranstype"));
   15150         860 :     aggtransspace = PQgetvalue(res, 0, PQfnumber(res, "aggtransspace"));
   15151         860 :     aggmtranstype = PQgetvalue(res, 0, PQfnumber(res, "aggmtranstype"));
   15152         860 :     aggmtransspace = PQgetvalue(res, 0, PQfnumber(res, "aggmtransspace"));
   15153         860 :     agginitval = PQgetvalue(res, 0, i_agginitval);
   15154         860 :     aggminitval = PQgetvalue(res, 0, i_aggminitval);
   15155         860 :     proparallel = PQgetvalue(res, 0, PQfnumber(res, "proparallel"));
   15156             : 
   15157             :     {
   15158             :         char       *funcargs;
   15159             :         char       *funciargs;
   15160             : 
   15161         860 :         funcargs = PQgetvalue(res, 0, PQfnumber(res, "funcargs"));
   15162         860 :         funciargs = PQgetvalue(res, 0, PQfnumber(res, "funciargs"));
   15163         860 :         aggfullsig = format_function_arguments(&agginfo->aggfn, funcargs, true);
   15164         860 :         aggsig = format_function_arguments(&agginfo->aggfn, funciargs, true);
   15165             :     }
   15166             : 
   15167         860 :     aggsig_tag = format_aggregate_signature(agginfo, fout, false);
   15168             : 
   15169             :     /* identify default modify flag for aggkind (must match DefineAggregate) */
   15170         860 :     defaultfinalmodify = (aggkind == AGGKIND_NORMAL) ? AGGMODIFY_READ_ONLY : AGGMODIFY_READ_WRITE;
   15171             :     /* replace omitted flags for old versions */
   15172         860 :     if (aggfinalmodify == '0')
   15173           0 :         aggfinalmodify = defaultfinalmodify;
   15174         860 :     if (aggmfinalmodify == '0')
   15175           0 :         aggmfinalmodify = defaultfinalmodify;
   15176             : 
   15177             :     /* regproc and regtype output is already sufficiently quoted */
   15178         860 :     appendPQExpBuffer(details, "    SFUNC = %s,\n    STYPE = %s",
   15179             :                       aggtransfn, aggtranstype);
   15180             : 
   15181         860 :     if (strcmp(aggtransspace, "0") != 0)
   15182             :     {
   15183          16 :         appendPQExpBuffer(details, ",\n    SSPACE = %s",
   15184             :                           aggtransspace);
   15185             :     }
   15186             : 
   15187         860 :     if (!PQgetisnull(res, 0, i_agginitval))
   15188             :     {
   15189         632 :         appendPQExpBufferStr(details, ",\n    INITCOND = ");
   15190         632 :         appendStringLiteralAH(details, agginitval, fout);
   15191             :     }
   15192             : 
   15193         860 :     if (strcmp(aggfinalfn, "-") != 0)
   15194             :     {
   15195         392 :         appendPQExpBuffer(details, ",\n    FINALFUNC = %s",
   15196             :                           aggfinalfn);
   15197         392 :         if (aggfinalextra)
   15198          32 :             appendPQExpBufferStr(details, ",\n    FINALFUNC_EXTRA");
   15199         392 :         if (aggfinalmodify != defaultfinalmodify)
   15200             :         {
   15201          72 :             switch (aggfinalmodify)
   15202             :             {
   15203           0 :                 case AGGMODIFY_READ_ONLY:
   15204           0 :                     appendPQExpBufferStr(details, ",\n    FINALFUNC_MODIFY = READ_ONLY");
   15205           0 :                     break;
   15206          72 :                 case AGGMODIFY_SHAREABLE:
   15207          72 :                     appendPQExpBufferStr(details, ",\n    FINALFUNC_MODIFY = SHAREABLE");
   15208          72 :                     break;
   15209           0 :                 case AGGMODIFY_READ_WRITE:
   15210           0 :                     appendPQExpBufferStr(details, ",\n    FINALFUNC_MODIFY = READ_WRITE");
   15211           0 :                     break;
   15212           0 :                 default:
   15213           0 :                     pg_fatal("unrecognized aggfinalmodify value for aggregate \"%s\"",
   15214             :                              agginfo->aggfn.dobj.name);
   15215             :                     break;
   15216             :             }
   15217         788 :         }
   15218             :     }
   15219             : 
   15220         860 :     if (strcmp(aggcombinefn, "-") != 0)
   15221           0 :         appendPQExpBuffer(details, ",\n    COMBINEFUNC = %s", aggcombinefn);
   15222             : 
   15223         860 :     if (strcmp(aggserialfn, "-") != 0)
   15224           0 :         appendPQExpBuffer(details, ",\n    SERIALFUNC = %s", aggserialfn);
   15225             : 
   15226         860 :     if (strcmp(aggdeserialfn, "-") != 0)
   15227           0 :         appendPQExpBuffer(details, ",\n    DESERIALFUNC = %s", aggdeserialfn);
   15228             : 
   15229         860 :     if (strcmp(aggmtransfn, "-") != 0)
   15230             :     {
   15231          96 :         appendPQExpBuffer(details, ",\n    MSFUNC = %s,\n    MINVFUNC = %s,\n    MSTYPE = %s",
   15232             :                           aggmtransfn,
   15233             :                           aggminvtransfn,
   15234             :                           aggmtranstype);
   15235             :     }
   15236             : 
   15237         860 :     if (strcmp(aggmtransspace, "0") != 0)
   15238             :     {
   15239           0 :         appendPQExpBuffer(details, ",\n    MSSPACE = %s",
   15240             :                           aggmtransspace);
   15241             :     }
   15242             : 
   15243         860 :     if (!PQgetisnull(res, 0, i_aggminitval))
   15244             :     {
   15245          32 :         appendPQExpBufferStr(details, ",\n    MINITCOND = ");
   15246          32 :         appendStringLiteralAH(details, aggminitval, fout);
   15247             :     }
   15248             : 
   15249         860 :     if (strcmp(aggmfinalfn, "-") != 0)
   15250             :     {
   15251           0 :         appendPQExpBuffer(details, ",\n    MFINALFUNC = %s",
   15252             :                           aggmfinalfn);
   15253           0 :         if (aggmfinalextra)
   15254           0 :             appendPQExpBufferStr(details, ",\n    MFINALFUNC_EXTRA");
   15255           0 :         if (aggmfinalmodify != defaultfinalmodify)
   15256             :         {
   15257           0 :             switch (aggmfinalmodify)
   15258             :             {
   15259           0 :                 case AGGMODIFY_READ_ONLY:
   15260           0 :                     appendPQExpBufferStr(details, ",\n    MFINALFUNC_MODIFY = READ_ONLY");
   15261           0 :                     break;
   15262           0 :                 case AGGMODIFY_SHAREABLE:
   15263           0 :                     appendPQExpBufferStr(details, ",\n    MFINALFUNC_MODIFY = SHAREABLE");
   15264           0 :                     break;
   15265           0 :                 case AGGMODIFY_READ_WRITE:
   15266           0 :                     appendPQExpBufferStr(details, ",\n    MFINALFUNC_MODIFY = READ_WRITE");
   15267           0 :                     break;
   15268           0 :                 default:
   15269           0 :                     pg_fatal("unrecognized aggmfinalmodify value for aggregate \"%s\"",
   15270             :                              agginfo->aggfn.dobj.name);
   15271             :                     break;
   15272             :             }
   15273         860 :         }
   15274             :     }
   15275             : 
   15276         860 :     aggsortconvop = getFormattedOperatorName(aggsortop);
   15277         860 :     if (aggsortconvop)
   15278             :     {
   15279           0 :         appendPQExpBuffer(details, ",\n    SORTOP = %s",
   15280             :                           aggsortconvop);
   15281           0 :         free(aggsortconvop);
   15282             :     }
   15283             : 
   15284         860 :     if (aggkind == AGGKIND_HYPOTHETICAL)
   15285          16 :         appendPQExpBufferStr(details, ",\n    HYPOTHETICAL");
   15286             : 
   15287         860 :     if (proparallel[0] != PROPARALLEL_UNSAFE)
   15288             :     {
   15289          16 :         if (proparallel[0] == PROPARALLEL_SAFE)
   15290          16 :             appendPQExpBufferStr(details, ",\n    PARALLEL = safe");
   15291           0 :         else if (proparallel[0] == PROPARALLEL_RESTRICTED)
   15292           0 :             appendPQExpBufferStr(details, ",\n    PARALLEL = restricted");
   15293           0 :         else if (proparallel[0] != PROPARALLEL_UNSAFE)
   15294           0 :             pg_fatal("unrecognized proparallel value for function \"%s\"",
   15295             :                      agginfo->aggfn.dobj.name);
   15296             :     }
   15297             : 
   15298         860 :     appendPQExpBuffer(delq, "DROP AGGREGATE %s.%s;\n",
   15299         860 :                       fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
   15300             :                       aggsig);
   15301             : 
   15302        1720 :     appendPQExpBuffer(q, "CREATE AGGREGATE %s.%s (\n%s\n);\n",
   15303         860 :                       fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
   15304             :                       aggfullsig ? aggfullsig : aggsig, details->data);
   15305             : 
   15306         860 :     if (dopt->binary_upgrade)
   15307          98 :         binary_upgrade_extension_member(q, &agginfo->aggfn.dobj,
   15308             :                                         "AGGREGATE", aggsig,
   15309          98 :                                         agginfo->aggfn.dobj.namespace->dobj.name);
   15310             : 
   15311         860 :     if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_DEFINITION)
   15312         826 :         ArchiveEntry(fout, agginfo->aggfn.dobj.catId,
   15313             :                      agginfo->aggfn.dobj.dumpId,
   15314         826 :                      ARCHIVE_OPTS(.tag = aggsig_tag,
   15315             :                                   .namespace = agginfo->aggfn.dobj.namespace->dobj.name,
   15316             :                                   .owner = agginfo->aggfn.rolname,
   15317             :                                   .description = "AGGREGATE",
   15318             :                                   .section = SECTION_PRE_DATA,
   15319             :                                   .createStmt = q->data,
   15320             :                                   .dropStmt = delq->data));
   15321             : 
   15322             :     /* Dump Aggregate Comments */
   15323         860 :     if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_COMMENT)
   15324          32 :         dumpComment(fout, "AGGREGATE", aggsig,
   15325          32 :                     agginfo->aggfn.dobj.namespace->dobj.name,
   15326             :                     agginfo->aggfn.rolname,
   15327             :                     agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
   15328             : 
   15329         860 :     if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_SECLABEL)
   15330           0 :         dumpSecLabel(fout, "AGGREGATE", aggsig,
   15331           0 :                      agginfo->aggfn.dobj.namespace->dobj.name,
   15332             :                      agginfo->aggfn.rolname,
   15333             :                      agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
   15334             : 
   15335             :     /*
   15336             :      * Since there is no GRANT ON AGGREGATE syntax, we have to make the ACL
   15337             :      * command look like a function's GRANT; in particular this affects the
   15338             :      * syntax for zero-argument aggregates and ordered-set aggregates.
   15339             :      */
   15340         860 :     free(aggsig);
   15341             : 
   15342         860 :     aggsig = format_function_signature(fout, &agginfo->aggfn, true);
   15343             : 
   15344         860 :     if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_ACL)
   15345          36 :         dumpACL(fout, agginfo->aggfn.dobj.dumpId, InvalidDumpId,
   15346             :                 "FUNCTION", aggsig, NULL,
   15347          36 :                 agginfo->aggfn.dobj.namespace->dobj.name,
   15348             :                 NULL, agginfo->aggfn.rolname, &agginfo->aggfn.dacl);
   15349             : 
   15350         860 :     free(aggsig);
   15351         860 :     free(aggfullsig);
   15352         860 :     free(aggsig_tag);
   15353             : 
   15354         860 :     PQclear(res);
   15355             : 
   15356         860 :     destroyPQExpBuffer(query);
   15357         860 :     destroyPQExpBuffer(q);
   15358         860 :     destroyPQExpBuffer(delq);
   15359         860 :     destroyPQExpBuffer(details);
   15360             : }
   15361             : 
   15362             : /*
   15363             :  * dumpTSParser
   15364             :  *    write out a single text search parser
   15365             :  */
   15366             : static void
   15367          90 : dumpTSParser(Archive *fout, const TSParserInfo *prsinfo)
   15368             : {
   15369          90 :     DumpOptions *dopt = fout->dopt;
   15370             :     PQExpBuffer q;
   15371             :     PQExpBuffer delq;
   15372             :     char       *qprsname;
   15373             : 
   15374             :     /* Do nothing if not dumping schema */
   15375          90 :     if (!dopt->dumpSchema)
   15376          12 :         return;
   15377             : 
   15378          78 :     q = createPQExpBuffer();
   15379          78 :     delq = createPQExpBuffer();
   15380             : 
   15381          78 :     qprsname = pg_strdup(fmtId(prsinfo->dobj.name));
   15382             : 
   15383          78 :     appendPQExpBuffer(q, "CREATE TEXT SEARCH PARSER %s (\n",
   15384          78 :                       fmtQualifiedDumpable(prsinfo));
   15385             : 
   15386          78 :     appendPQExpBuffer(q, "    START = %s,\n",
   15387             :                       convertTSFunction(fout, prsinfo->prsstart));
   15388          78 :     appendPQExpBuffer(q, "    GETTOKEN = %s,\n",
   15389             :                       convertTSFunction(fout, prsinfo->prstoken));
   15390          78 :     appendPQExpBuffer(q, "    END = %s,\n",
   15391             :                       convertTSFunction(fout, prsinfo->prsend));
   15392          78 :     if (prsinfo->prsheadline != InvalidOid)
   15393           6 :         appendPQExpBuffer(q, "    HEADLINE = %s,\n",
   15394             :                           convertTSFunction(fout, prsinfo->prsheadline));
   15395          78 :     appendPQExpBuffer(q, "    LEXTYPES = %s );\n",
   15396             :                       convertTSFunction(fout, prsinfo->prslextype));
   15397             : 
   15398          78 :     appendPQExpBuffer(delq, "DROP TEXT SEARCH PARSER %s;\n",
   15399          78 :                       fmtQualifiedDumpable(prsinfo));
   15400             : 
   15401          78 :     if (dopt->binary_upgrade)
   15402           2 :         binary_upgrade_extension_member(q, &prsinfo->dobj,
   15403             :                                         "TEXT SEARCH PARSER", qprsname,
   15404           2 :                                         prsinfo->dobj.namespace->dobj.name);
   15405             : 
   15406          78 :     if (prsinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   15407          78 :         ArchiveEntry(fout, prsinfo->dobj.catId, prsinfo->dobj.dumpId,
   15408          78 :                      ARCHIVE_OPTS(.tag = prsinfo->dobj.name,
   15409             :                                   .namespace = prsinfo->dobj.namespace->dobj.name,
   15410             :                                   .description = "TEXT SEARCH PARSER",
   15411             :                                   .section = SECTION_PRE_DATA,
   15412             :                                   .createStmt = q->data,
   15413             :                                   .dropStmt = delq->data));
   15414             : 
   15415             :     /* Dump Parser Comments */
   15416          78 :     if (prsinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   15417          78 :         dumpComment(fout, "TEXT SEARCH PARSER", qprsname,
   15418          78 :                     prsinfo->dobj.namespace->dobj.name, "",
   15419             :                     prsinfo->dobj.catId, 0, prsinfo->dobj.dumpId);
   15420             : 
   15421          78 :     destroyPQExpBuffer(q);
   15422          78 :     destroyPQExpBuffer(delq);
   15423          78 :     free(qprsname);
   15424             : }
   15425             : 
   15426             : /*
   15427             :  * dumpTSDictionary
   15428             :  *    write out a single text search dictionary
   15429             :  */
   15430             : static void
   15431         408 : dumpTSDictionary(Archive *fout, const TSDictInfo *dictinfo)
   15432             : {
   15433         408 :     DumpOptions *dopt = fout->dopt;
   15434             :     PQExpBuffer q;
   15435             :     PQExpBuffer delq;
   15436             :     PQExpBuffer query;
   15437             :     char       *qdictname;
   15438             :     PGresult   *res;
   15439             :     char       *nspname;
   15440             :     char       *tmplname;
   15441             : 
   15442             :     /* Do nothing if not dumping schema */
   15443         408 :     if (!dopt->dumpSchema)
   15444          12 :         return;
   15445             : 
   15446         396 :     q = createPQExpBuffer();
   15447         396 :     delq = createPQExpBuffer();
   15448         396 :     query = createPQExpBuffer();
   15449             : 
   15450         396 :     qdictname = pg_strdup(fmtId(dictinfo->dobj.name));
   15451             : 
   15452             :     /* Fetch name and namespace of the dictionary's template */
   15453         396 :     appendPQExpBuffer(query, "SELECT nspname, tmplname "
   15454             :                       "FROM pg_ts_template p, pg_namespace n "
   15455             :                       "WHERE p.oid = '%u' AND n.oid = tmplnamespace",
   15456             :                       dictinfo->dicttemplate);
   15457         396 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   15458         396 :     nspname = PQgetvalue(res, 0, 0);
   15459         396 :     tmplname = PQgetvalue(res, 0, 1);
   15460             : 
   15461         396 :     appendPQExpBuffer(q, "CREATE TEXT SEARCH DICTIONARY %s (\n",
   15462         396 :                       fmtQualifiedDumpable(dictinfo));
   15463             : 
   15464         396 :     appendPQExpBufferStr(q, "    TEMPLATE = ");
   15465         396 :     appendPQExpBuffer(q, "%s.", fmtId(nspname));
   15466         396 :     appendPQExpBufferStr(q, fmtId(tmplname));
   15467             : 
   15468         396 :     PQclear(res);
   15469             : 
   15470             :     /* the dictinitoption can be dumped straight into the command */
   15471         396 :     if (dictinfo->dictinitoption)
   15472         318 :         appendPQExpBuffer(q, ",\n    %s", dictinfo->dictinitoption);
   15473             : 
   15474         396 :     appendPQExpBufferStr(q, " );\n");
   15475             : 
   15476         396 :     appendPQExpBuffer(delq, "DROP TEXT SEARCH DICTIONARY %s;\n",
   15477         396 :                       fmtQualifiedDumpable(dictinfo));
   15478             : 
   15479         396 :     if (dopt->binary_upgrade)
   15480          20 :         binary_upgrade_extension_member(q, &dictinfo->dobj,
   15481             :                                         "TEXT SEARCH DICTIONARY", qdictname,
   15482          20 :                                         dictinfo->dobj.namespace->dobj.name);
   15483             : 
   15484         396 :     if (dictinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   15485         396 :         ArchiveEntry(fout, dictinfo->dobj.catId, dictinfo->dobj.dumpId,
   15486         396 :                      ARCHIVE_OPTS(.tag = dictinfo->dobj.name,
   15487             :                                   .namespace = dictinfo->dobj.namespace->dobj.name,
   15488             :                                   .owner = dictinfo->rolname,
   15489             :                                   .description = "TEXT SEARCH DICTIONARY",
   15490             :                                   .section = SECTION_PRE_DATA,
   15491             :                                   .createStmt = q->data,
   15492             :                                   .dropStmt = delq->data));
   15493             : 
   15494             :     /* Dump Dictionary Comments */
   15495         396 :     if (dictinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   15496         252 :         dumpComment(fout, "TEXT SEARCH DICTIONARY", qdictname,
   15497         252 :                     dictinfo->dobj.namespace->dobj.name, dictinfo->rolname,
   15498             :                     dictinfo->dobj.catId, 0, dictinfo->dobj.dumpId);
   15499             : 
   15500         396 :     destroyPQExpBuffer(q);
   15501         396 :     destroyPQExpBuffer(delq);
   15502         396 :     destroyPQExpBuffer(query);
   15503         396 :     free(qdictname);
   15504             : }
   15505             : 
   15506             : /*
   15507             :  * dumpTSTemplate
   15508             :  *    write out a single text search template
   15509             :  */
   15510             : static void
   15511         114 : dumpTSTemplate(Archive *fout, const TSTemplateInfo *tmplinfo)
   15512             : {
   15513         114 :     DumpOptions *dopt = fout->dopt;
   15514             :     PQExpBuffer q;
   15515             :     PQExpBuffer delq;
   15516             :     char       *qtmplname;
   15517             : 
   15518             :     /* Do nothing if not dumping schema */
   15519         114 :     if (!dopt->dumpSchema)
   15520          12 :         return;
   15521             : 
   15522         102 :     q = createPQExpBuffer();
   15523         102 :     delq = createPQExpBuffer();
   15524             : 
   15525         102 :     qtmplname = pg_strdup(fmtId(tmplinfo->dobj.name));
   15526             : 
   15527         102 :     appendPQExpBuffer(q, "CREATE TEXT SEARCH TEMPLATE %s (\n",
   15528         102 :                       fmtQualifiedDumpable(tmplinfo));
   15529             : 
   15530         102 :     if (tmplinfo->tmplinit != InvalidOid)
   15531          30 :         appendPQExpBuffer(q, "    INIT = %s,\n",
   15532             :                           convertTSFunction(fout, tmplinfo->tmplinit));
   15533         102 :     appendPQExpBuffer(q, "    LEXIZE = %s );\n",
   15534             :                       convertTSFunction(fout, tmplinfo->tmpllexize));
   15535             : 
   15536         102 :     appendPQExpBuffer(delq, "DROP TEXT SEARCH TEMPLATE %s;\n",
   15537         102 :                       fmtQualifiedDumpable(tmplinfo));
   15538             : 
   15539         102 :     if (dopt->binary_upgrade)
   15540           2 :         binary_upgrade_extension_member(q, &tmplinfo->dobj,
   15541             :                                         "TEXT SEARCH TEMPLATE", qtmplname,
   15542           2 :                                         tmplinfo->dobj.namespace->dobj.name);
   15543             : 
   15544         102 :     if (tmplinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   15545         102 :         ArchiveEntry(fout, tmplinfo->dobj.catId, tmplinfo->dobj.dumpId,
   15546         102 :                      ARCHIVE_OPTS(.tag = tmplinfo->dobj.name,
   15547             :                                   .namespace = tmplinfo->dobj.namespace->dobj.name,
   15548             :                                   .description = "TEXT SEARCH TEMPLATE",
   15549             :                                   .section = SECTION_PRE_DATA,
   15550             :                                   .createStmt = q->data,
   15551             :                                   .dropStmt = delq->data));
   15552             : 
   15553             :     /* Dump Template Comments */
   15554         102 :     if (tmplinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   15555         102 :         dumpComment(fout, "TEXT SEARCH TEMPLATE", qtmplname,
   15556         102 :                     tmplinfo->dobj.namespace->dobj.name, "",
   15557             :                     tmplinfo->dobj.catId, 0, tmplinfo->dobj.dumpId);
   15558             : 
   15559         102 :     destroyPQExpBuffer(q);
   15560         102 :     destroyPQExpBuffer(delq);
   15561         102 :     free(qtmplname);
   15562             : }
   15563             : 
   15564             : /*
   15565             :  * dumpTSConfig
   15566             :  *    write out a single text search configuration
   15567             :  */
   15568             : static void
   15569         328 : dumpTSConfig(Archive *fout, const TSConfigInfo *cfginfo)
   15570             : {
   15571         328 :     DumpOptions *dopt = fout->dopt;
   15572             :     PQExpBuffer q;
   15573             :     PQExpBuffer delq;
   15574             :     PQExpBuffer query;
   15575             :     char       *qcfgname;
   15576             :     PGresult   *res;
   15577             :     char       *nspname;
   15578             :     char       *prsname;
   15579             :     int         ntups,
   15580             :                 i;
   15581             :     int         i_tokenname;
   15582             :     int         i_dictname;
   15583             : 
   15584             :     /* Do nothing if not dumping schema */
   15585         328 :     if (!dopt->dumpSchema)
   15586          12 :         return;
   15587             : 
   15588         316 :     q = createPQExpBuffer();
   15589         316 :     delq = createPQExpBuffer();
   15590         316 :     query = createPQExpBuffer();
   15591             : 
   15592         316 :     qcfgname = pg_strdup(fmtId(cfginfo->dobj.name));
   15593             : 
   15594             :     /* Fetch name and namespace of the config's parser */
   15595         316 :     appendPQExpBuffer(query, "SELECT nspname, prsname "
   15596             :                       "FROM pg_ts_parser p, pg_namespace n "
   15597             :                       "WHERE p.oid = '%u' AND n.oid = prsnamespace",
   15598             :                       cfginfo->cfgparser);
   15599         316 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   15600         316 :     nspname = PQgetvalue(res, 0, 0);
   15601         316 :     prsname = PQgetvalue(res, 0, 1);
   15602             : 
   15603         316 :     appendPQExpBuffer(q, "CREATE TEXT SEARCH CONFIGURATION %s (\n",
   15604         316 :                       fmtQualifiedDumpable(cfginfo));
   15605             : 
   15606         316 :     appendPQExpBuffer(q, "    PARSER = %s.", fmtId(nspname));
   15607         316 :     appendPQExpBuffer(q, "%s );\n", fmtId(prsname));
   15608             : 
   15609         316 :     PQclear(res);
   15610             : 
   15611         316 :     resetPQExpBuffer(query);
   15612         316 :     appendPQExpBuffer(query,
   15613             :                       "SELECT\n"
   15614             :                       "  ( SELECT alias FROM pg_catalog.ts_token_type('%u'::pg_catalog.oid) AS t\n"
   15615             :                       "    WHERE t.tokid = m.maptokentype ) AS tokenname,\n"
   15616             :                       "  m.mapdict::pg_catalog.regdictionary AS dictname\n"
   15617             :                       "FROM pg_catalog.pg_ts_config_map AS m\n"
   15618             :                       "WHERE m.mapcfg = '%u'\n"
   15619             :                       "ORDER BY m.mapcfg, m.maptokentype, m.mapseqno",
   15620             :                       cfginfo->cfgparser, cfginfo->dobj.catId.oid);
   15621             : 
   15622         316 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   15623         316 :     ntups = PQntuples(res);
   15624             : 
   15625         316 :     i_tokenname = PQfnumber(res, "tokenname");
   15626         316 :     i_dictname = PQfnumber(res, "dictname");
   15627             : 
   15628        6752 :     for (i = 0; i < ntups; i++)
   15629             :     {
   15630        6436 :         char       *tokenname = PQgetvalue(res, i, i_tokenname);
   15631        6436 :         char       *dictname = PQgetvalue(res, i, i_dictname);
   15632             : 
   15633        6436 :         if (i == 0 ||
   15634        6120 :             strcmp(tokenname, PQgetvalue(res, i - 1, i_tokenname)) != 0)
   15635             :         {
   15636             :             /* starting a new token type, so start a new command */
   15637        6004 :             if (i > 0)
   15638        5688 :                 appendPQExpBufferStr(q, ";\n");
   15639        6004 :             appendPQExpBuffer(q, "\nALTER TEXT SEARCH CONFIGURATION %s\n",
   15640        6004 :                               fmtQualifiedDumpable(cfginfo));
   15641             :             /* tokenname needs quoting, dictname does NOT */
   15642        6004 :             appendPQExpBuffer(q, "    ADD MAPPING FOR %s WITH %s",
   15643             :                               fmtId(tokenname), dictname);
   15644             :         }
   15645             :         else
   15646         432 :             appendPQExpBuffer(q, ", %s", dictname);
   15647             :     }
   15648             : 
   15649         316 :     if (ntups > 0)
   15650         316 :         appendPQExpBufferStr(q, ";\n");
   15651             : 
   15652         316 :     PQclear(res);
   15653             : 
   15654         316 :     appendPQExpBuffer(delq, "DROP TEXT SEARCH CONFIGURATION %s;\n",
   15655         316 :                       fmtQualifiedDumpable(cfginfo));
   15656             : 
   15657         316 :     if (dopt->binary_upgrade)
   15658          10 :         binary_upgrade_extension_member(q, &cfginfo->dobj,
   15659             :                                         "TEXT SEARCH CONFIGURATION", qcfgname,
   15660          10 :                                         cfginfo->dobj.namespace->dobj.name);
   15661             : 
   15662         316 :     if (cfginfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   15663         316 :         ArchiveEntry(fout, cfginfo->dobj.catId, cfginfo->dobj.dumpId,
   15664         316 :                      ARCHIVE_OPTS(.tag = cfginfo->dobj.name,
   15665             :                                   .namespace = cfginfo->dobj.namespace->dobj.name,
   15666             :                                   .owner = cfginfo->rolname,
   15667             :                                   .description = "TEXT SEARCH CONFIGURATION",
   15668             :                                   .section = SECTION_PRE_DATA,
   15669             :                                   .createStmt = q->data,
   15670             :                                   .dropStmt = delq->data));
   15671             : 
   15672             :     /* Dump Configuration Comments */
   15673         316 :     if (cfginfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   15674         252 :         dumpComment(fout, "TEXT SEARCH CONFIGURATION", qcfgname,
   15675         252 :                     cfginfo->dobj.namespace->dobj.name, cfginfo->rolname,
   15676             :                     cfginfo->dobj.catId, 0, cfginfo->dobj.dumpId);
   15677             : 
   15678         316 :     destroyPQExpBuffer(q);
   15679         316 :     destroyPQExpBuffer(delq);
   15680         316 :     destroyPQExpBuffer(query);
   15681         316 :     free(qcfgname);
   15682             : }
   15683             : 
   15684             : /*
   15685             :  * dumpForeignDataWrapper
   15686             :  *    write out a single foreign-data wrapper definition
   15687             :  */
   15688             : static void
   15689         118 : dumpForeignDataWrapper(Archive *fout, const FdwInfo *fdwinfo)
   15690             : {
   15691         118 :     DumpOptions *dopt = fout->dopt;
   15692             :     PQExpBuffer q;
   15693             :     PQExpBuffer delq;
   15694             :     char       *qfdwname;
   15695             : 
   15696             :     /* Do nothing if not dumping schema */
   15697         118 :     if (!dopt->dumpSchema)
   15698          14 :         return;
   15699             : 
   15700         104 :     q = createPQExpBuffer();
   15701         104 :     delq = createPQExpBuffer();
   15702             : 
   15703         104 :     qfdwname = pg_strdup(fmtId(fdwinfo->dobj.name));
   15704             : 
   15705         104 :     appendPQExpBuffer(q, "CREATE FOREIGN DATA WRAPPER %s",
   15706             :                       qfdwname);
   15707             : 
   15708         104 :     if (strcmp(fdwinfo->fdwhandler, "-") != 0)
   15709           0 :         appendPQExpBuffer(q, " HANDLER %s", fdwinfo->fdwhandler);
   15710             : 
   15711         104 :     if (strcmp(fdwinfo->fdwvalidator, "-") != 0)
   15712           0 :         appendPQExpBuffer(q, " VALIDATOR %s", fdwinfo->fdwvalidator);
   15713             : 
   15714         104 :     if (strlen(fdwinfo->fdwoptions) > 0)
   15715           0 :         appendPQExpBuffer(q, " OPTIONS (\n    %s\n)", fdwinfo->fdwoptions);
   15716             : 
   15717         104 :     appendPQExpBufferStr(q, ";\n");
   15718             : 
   15719         104 :     appendPQExpBuffer(delq, "DROP FOREIGN DATA WRAPPER %s;\n",
   15720             :                       qfdwname);
   15721             : 
   15722         104 :     if (dopt->binary_upgrade)
   15723           4 :         binary_upgrade_extension_member(q, &fdwinfo->dobj,
   15724             :                                         "FOREIGN DATA WRAPPER", qfdwname,
   15725             :                                         NULL);
   15726             : 
   15727         104 :     if (fdwinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   15728         104 :         ArchiveEntry(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
   15729         104 :                      ARCHIVE_OPTS(.tag = fdwinfo->dobj.name,
   15730             :                                   .owner = fdwinfo->rolname,
   15731             :                                   .description = "FOREIGN DATA WRAPPER",
   15732             :                                   .section = SECTION_PRE_DATA,
   15733             :                                   .createStmt = q->data,
   15734             :                                   .dropStmt = delq->data));
   15735             : 
   15736             :     /* Dump Foreign Data Wrapper Comments */
   15737         104 :     if (fdwinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   15738           0 :         dumpComment(fout, "FOREIGN DATA WRAPPER", qfdwname,
   15739             :                     NULL, fdwinfo->rolname,
   15740             :                     fdwinfo->dobj.catId, 0, fdwinfo->dobj.dumpId);
   15741             : 
   15742             :     /* Handle the ACL */
   15743         104 :     if (fdwinfo->dobj.dump & DUMP_COMPONENT_ACL)
   15744          70 :         dumpACL(fout, fdwinfo->dobj.dumpId, InvalidDumpId,
   15745             :                 "FOREIGN DATA WRAPPER", qfdwname, NULL, NULL,
   15746             :                 NULL, fdwinfo->rolname, &fdwinfo->dacl);
   15747             : 
   15748         104 :     free(qfdwname);
   15749             : 
   15750         104 :     destroyPQExpBuffer(q);
   15751         104 :     destroyPQExpBuffer(delq);
   15752             : }
   15753             : 
   15754             : /*
   15755             :  * dumpForeignServer
   15756             :  *    write out a foreign server definition
   15757             :  */
   15758             : static void
   15759         126 : dumpForeignServer(Archive *fout, const ForeignServerInfo *srvinfo)
   15760             : {
   15761         126 :     DumpOptions *dopt = fout->dopt;
   15762             :     PQExpBuffer q;
   15763             :     PQExpBuffer delq;
   15764             :     PQExpBuffer query;
   15765             :     PGresult   *res;
   15766             :     char       *qsrvname;
   15767             :     char       *fdwname;
   15768             : 
   15769             :     /* Do nothing if not dumping schema */
   15770         126 :     if (!dopt->dumpSchema)
   15771          18 :         return;
   15772             : 
   15773         108 :     q = createPQExpBuffer();
   15774         108 :     delq = createPQExpBuffer();
   15775         108 :     query = createPQExpBuffer();
   15776             : 
   15777         108 :     qsrvname = pg_strdup(fmtId(srvinfo->dobj.name));
   15778             : 
   15779             :     /* look up the foreign-data wrapper */
   15780         108 :     appendPQExpBuffer(query, "SELECT fdwname "
   15781             :                       "FROM pg_foreign_data_wrapper w "
   15782             :                       "WHERE w.oid = '%u'",
   15783             :                       srvinfo->srvfdw);
   15784         108 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   15785         108 :     fdwname = PQgetvalue(res, 0, 0);
   15786             : 
   15787         108 :     appendPQExpBuffer(q, "CREATE SERVER %s", qsrvname);
   15788         108 :     if (srvinfo->srvtype && strlen(srvinfo->srvtype) > 0)
   15789             :     {
   15790           0 :         appendPQExpBufferStr(q, " TYPE ");
   15791           0 :         appendStringLiteralAH(q, srvinfo->srvtype, fout);
   15792             :     }
   15793         108 :     if (srvinfo->srvversion && strlen(srvinfo->srvversion) > 0)
   15794             :     {
   15795           0 :         appendPQExpBufferStr(q, " VERSION ");
   15796           0 :         appendStringLiteralAH(q, srvinfo->srvversion, fout);
   15797             :     }
   15798             : 
   15799         108 :     appendPQExpBufferStr(q, " FOREIGN DATA WRAPPER ");
   15800         108 :     appendPQExpBufferStr(q, fmtId(fdwname));
   15801             : 
   15802         108 :     if (srvinfo->srvoptions && strlen(srvinfo->srvoptions) > 0)
   15803           0 :         appendPQExpBuffer(q, " OPTIONS (\n    %s\n)", srvinfo->srvoptions);
   15804             : 
   15805         108 :     appendPQExpBufferStr(q, ";\n");
   15806             : 
   15807         108 :     appendPQExpBuffer(delq, "DROP SERVER %s;\n",
   15808             :                       qsrvname);
   15809             : 
   15810         108 :     if (dopt->binary_upgrade)
   15811           4 :         binary_upgrade_extension_member(q, &srvinfo->dobj,
   15812             :                                         "SERVER", qsrvname, NULL);
   15813             : 
   15814         108 :     if (srvinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   15815         108 :         ArchiveEntry(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
   15816         108 :                      ARCHIVE_OPTS(.tag = srvinfo->dobj.name,
   15817             :                                   .owner = srvinfo->rolname,
   15818             :                                   .description = "SERVER",
   15819             :                                   .section = SECTION_PRE_DATA,
   15820             :                                   .createStmt = q->data,
   15821             :                                   .dropStmt = delq->data));
   15822             : 
   15823             :     /* Dump Foreign Server Comments */
   15824         108 :     if (srvinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   15825           0 :         dumpComment(fout, "SERVER", qsrvname,
   15826             :                     NULL, srvinfo->rolname,
   15827             :                     srvinfo->dobj.catId, 0, srvinfo->dobj.dumpId);
   15828             : 
   15829             :     /* Handle the ACL */
   15830         108 :     if (srvinfo->dobj.dump & DUMP_COMPONENT_ACL)
   15831          70 :         dumpACL(fout, srvinfo->dobj.dumpId, InvalidDumpId,
   15832             :                 "FOREIGN SERVER", qsrvname, NULL, NULL,
   15833             :                 NULL, srvinfo->rolname, &srvinfo->dacl);
   15834             : 
   15835             :     /* Dump user mappings */
   15836         108 :     if (srvinfo->dobj.dump & DUMP_COMPONENT_USERMAP)
   15837         108 :         dumpUserMappings(fout,
   15838         108 :                          srvinfo->dobj.name, NULL,
   15839             :                          srvinfo->rolname,
   15840             :                          srvinfo->dobj.catId, srvinfo->dobj.dumpId);
   15841             : 
   15842         108 :     PQclear(res);
   15843             : 
   15844         108 :     free(qsrvname);
   15845             : 
   15846         108 :     destroyPQExpBuffer(q);
   15847         108 :     destroyPQExpBuffer(delq);
   15848         108 :     destroyPQExpBuffer(query);
   15849             : }
   15850             : 
   15851             : /*
   15852             :  * dumpUserMappings
   15853             :  *
   15854             :  * This routine is used to dump any user mappings associated with the
   15855             :  * server handed to this routine. Should be called after ArchiveEntry()
   15856             :  * for the server.
   15857             :  */
   15858             : static void
   15859         108 : dumpUserMappings(Archive *fout,
   15860             :                  const char *servername, const char *namespace,
   15861             :                  const char *owner,
   15862             :                  CatalogId catalogId, DumpId dumpId)
   15863             : {
   15864             :     PQExpBuffer q;
   15865             :     PQExpBuffer delq;
   15866             :     PQExpBuffer query;
   15867             :     PQExpBuffer tag;
   15868             :     PGresult   *res;
   15869             :     int         ntups;
   15870             :     int         i_usename;
   15871             :     int         i_umoptions;
   15872             :     int         i;
   15873             : 
   15874         108 :     q = createPQExpBuffer();
   15875         108 :     tag = createPQExpBuffer();
   15876         108 :     delq = createPQExpBuffer();
   15877         108 :     query = createPQExpBuffer();
   15878             : 
   15879             :     /*
   15880             :      * We read from the publicly accessible view pg_user_mappings, so as not
   15881             :      * to fail if run by a non-superuser.  Note that the view will show
   15882             :      * umoptions as null if the user hasn't got privileges for the associated
   15883             :      * server; this means that pg_dump will dump such a mapping, but with no
   15884             :      * OPTIONS clause.  A possible alternative is to skip such mappings
   15885             :      * altogether, but it's not clear that that's an improvement.
   15886             :      */
   15887         108 :     appendPQExpBuffer(query,
   15888             :                       "SELECT usename, "
   15889             :                       "array_to_string(ARRAY("
   15890             :                       "SELECT quote_ident(option_name) || ' ' || "
   15891             :                       "quote_literal(option_value) "
   15892             :                       "FROM pg_options_to_table(umoptions) "
   15893             :                       "ORDER BY option_name"
   15894             :                       "), E',\n    ') AS umoptions "
   15895             :                       "FROM pg_user_mappings "
   15896             :                       "WHERE srvid = '%u' "
   15897             :                       "ORDER BY usename",
   15898             :                       catalogId.oid);
   15899             : 
   15900         108 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   15901             : 
   15902         108 :     ntups = PQntuples(res);
   15903         108 :     i_usename = PQfnumber(res, "usename");
   15904         108 :     i_umoptions = PQfnumber(res, "umoptions");
   15905             : 
   15906         178 :     for (i = 0; i < ntups; i++)
   15907             :     {
   15908             :         char       *usename;
   15909             :         char       *umoptions;
   15910             : 
   15911          70 :         usename = PQgetvalue(res, i, i_usename);
   15912          70 :         umoptions = PQgetvalue(res, i, i_umoptions);
   15913             : 
   15914          70 :         resetPQExpBuffer(q);
   15915          70 :         appendPQExpBuffer(q, "CREATE USER MAPPING FOR %s", fmtId(usename));
   15916          70 :         appendPQExpBuffer(q, " SERVER %s", fmtId(servername));
   15917             : 
   15918          70 :         if (umoptions && strlen(umoptions) > 0)
   15919           0 :             appendPQExpBuffer(q, " OPTIONS (\n    %s\n)", umoptions);
   15920             : 
   15921          70 :         appendPQExpBufferStr(q, ";\n");
   15922             : 
   15923          70 :         resetPQExpBuffer(delq);
   15924          70 :         appendPQExpBuffer(delq, "DROP USER MAPPING FOR %s", fmtId(usename));
   15925          70 :         appendPQExpBuffer(delq, " SERVER %s;\n", fmtId(servername));
   15926             : 
   15927          70 :         resetPQExpBuffer(tag);
   15928          70 :         appendPQExpBuffer(tag, "USER MAPPING %s SERVER %s",
   15929             :                           usename, servername);
   15930             : 
   15931          70 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
   15932          70 :                      ARCHIVE_OPTS(.tag = tag->data,
   15933             :                                   .namespace = namespace,
   15934             :                                   .owner = owner,
   15935             :                                   .description = "USER MAPPING",
   15936             :                                   .section = SECTION_PRE_DATA,
   15937             :                                   .createStmt = q->data,
   15938             :                                   .dropStmt = delq->data));
   15939             :     }
   15940             : 
   15941         108 :     PQclear(res);
   15942             : 
   15943         108 :     destroyPQExpBuffer(query);
   15944         108 :     destroyPQExpBuffer(delq);
   15945         108 :     destroyPQExpBuffer(tag);
   15946         108 :     destroyPQExpBuffer(q);
   15947         108 : }
   15948             : 
   15949             : /*
   15950             :  * Write out default privileges information
   15951             :  */
   15952             : static void
   15953         332 : dumpDefaultACL(Archive *fout, const DefaultACLInfo *daclinfo)
   15954             : {
   15955         332 :     DumpOptions *dopt = fout->dopt;
   15956             :     PQExpBuffer q;
   15957             :     PQExpBuffer tag;
   15958             :     const char *type;
   15959             : 
   15960             :     /* Do nothing if not dumping schema, or if we're skipping ACLs */
   15961         332 :     if (!dopt->dumpSchema || dopt->aclsSkip)
   15962          56 :         return;
   15963             : 
   15964         276 :     q = createPQExpBuffer();
   15965         276 :     tag = createPQExpBuffer();
   15966             : 
   15967         276 :     switch (daclinfo->defaclobjtype)
   15968             :     {
   15969         138 :         case DEFACLOBJ_RELATION:
   15970         138 :             type = "TABLES";
   15971         138 :             break;
   15972           0 :         case DEFACLOBJ_SEQUENCE:
   15973           0 :             type = "SEQUENCES";
   15974           0 :             break;
   15975         138 :         case DEFACLOBJ_FUNCTION:
   15976         138 :             type = "FUNCTIONS";
   15977         138 :             break;
   15978           0 :         case DEFACLOBJ_TYPE:
   15979           0 :             type = "TYPES";
   15980           0 :             break;
   15981           0 :         case DEFACLOBJ_NAMESPACE:
   15982           0 :             type = "SCHEMAS";
   15983           0 :             break;
   15984           0 :         case DEFACLOBJ_LARGEOBJECT:
   15985           0 :             type = "LARGE OBJECTS";
   15986           0 :             break;
   15987           0 :         default:
   15988             :             /* shouldn't get here */
   15989           0 :             pg_fatal("unrecognized object type in default privileges: %d",
   15990             :                      (int) daclinfo->defaclobjtype);
   15991             :             type = "";            /* keep compiler quiet */
   15992             :     }
   15993             : 
   15994         276 :     appendPQExpBuffer(tag, "DEFAULT PRIVILEGES FOR %s", type);
   15995             : 
   15996             :     /* build the actual command(s) for this tuple */
   15997         276 :     if (!buildDefaultACLCommands(type,
   15998         276 :                                  daclinfo->dobj.namespace != NULL ?
   15999         140 :                                  daclinfo->dobj.namespace->dobj.name : NULL,
   16000         276 :                                  daclinfo->dacl.acl,
   16001         276 :                                  daclinfo->dacl.acldefault,
   16002             :                                  daclinfo->defaclrole,
   16003             :                                  fout->remoteVersion,
   16004             :                                  q))
   16005           0 :         pg_fatal("could not parse default ACL list (%s)",
   16006             :                  daclinfo->dacl.acl);
   16007             : 
   16008         276 :     if (daclinfo->dobj.dump & DUMP_COMPONENT_ACL)
   16009         276 :         ArchiveEntry(fout, daclinfo->dobj.catId, daclinfo->dobj.dumpId,
   16010         276 :                      ARCHIVE_OPTS(.tag = tag->data,
   16011             :                                   .namespace = daclinfo->dobj.namespace ?
   16012             :                                   daclinfo->dobj.namespace->dobj.name : NULL,
   16013             :                                   .owner = daclinfo->defaclrole,
   16014             :                                   .description = "DEFAULT ACL",
   16015             :                                   .section = SECTION_POST_DATA,
   16016             :                                   .createStmt = q->data));
   16017             : 
   16018         276 :     destroyPQExpBuffer(tag);
   16019         276 :     destroyPQExpBuffer(q);
   16020             : }
   16021             : 
   16022             : /*----------
   16023             :  * Write out grant/revoke information
   16024             :  *
   16025             :  * 'objDumpId' is the dump ID of the underlying object.
   16026             :  * 'altDumpId' can be a second dumpId that the ACL entry must also depend on,
   16027             :  *      or InvalidDumpId if there is no need for a second dependency.
   16028             :  * 'type' must be one of
   16029             :  *      TABLE, SEQUENCE, FUNCTION, LANGUAGE, SCHEMA, DATABASE, TABLESPACE,
   16030             :  *      FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
   16031             :  * 'name' is the formatted name of the object.  Must be quoted etc. already.
   16032             :  * 'subname' is the formatted name of the sub-object, if any.  Must be quoted.
   16033             :  *      (Currently we assume that subname is only provided for table columns.)
   16034             :  * 'nspname' is the namespace the object is in (NULL if none).
   16035             :  * 'tag' is the tag to use for the ACL TOC entry; typically, this is NULL
   16036             :  *      to use the default for the object type.
   16037             :  * 'owner' is the owner, NULL if there is no owner (for languages).
   16038             :  * 'dacl' is the DumpableAcl struct for the object.
   16039             :  *
   16040             :  * Returns the dump ID assigned to the ACL TocEntry, or InvalidDumpId if
   16041             :  * no ACL entry was created.
   16042             :  *----------
   16043             :  */
   16044             : static DumpId
   16045       72052 : dumpACL(Archive *fout, DumpId objDumpId, DumpId altDumpId,
   16046             :         const char *type, const char *name, const char *subname,
   16047             :         const char *nspname, const char *tag, const char *owner,
   16048             :         const DumpableAcl *dacl)
   16049             : {
   16050       72052 :     DumpId      aclDumpId = InvalidDumpId;
   16051       72052 :     DumpOptions *dopt = fout->dopt;
   16052       72052 :     const char *acls = dacl->acl;
   16053       72052 :     const char *acldefault = dacl->acldefault;
   16054       72052 :     char        privtype = dacl->privtype;
   16055       72052 :     const char *initprivs = dacl->initprivs;
   16056             :     const char *baseacls;
   16057             :     PQExpBuffer sql;
   16058             : 
   16059             :     /* Do nothing if ACL dump is not enabled */
   16060       72052 :     if (dopt->aclsSkip)
   16061         644 :         return InvalidDumpId;
   16062             : 
   16063             :     /* --data-only skips ACLs *except* large object ACLs */
   16064       71408 :     if (!dopt->dumpSchema && strcmp(type, "LARGE OBJECT") != 0)
   16065           0 :         return InvalidDumpId;
   16066             : 
   16067       71408 :     sql = createPQExpBuffer();
   16068             : 
   16069             :     /*
   16070             :      * In binary upgrade mode, we don't run an extension's script but instead
   16071             :      * dump out the objects independently and then recreate them.  To preserve
   16072             :      * any initial privileges which were set on extension objects, we need to
   16073             :      * compute the set of GRANT and REVOKE commands necessary to get from the
   16074             :      * default privileges of an object to its initial privileges as recorded
   16075             :      * in pg_init_privs.
   16076             :      *
   16077             :      * At restore time, we apply these commands after having called
   16078             :      * binary_upgrade_set_record_init_privs(true).  That tells the backend to
   16079             :      * copy the results into pg_init_privs.  This is how we preserve the
   16080             :      * contents of that catalog across binary upgrades.
   16081             :      */
   16082       71408 :     if (dopt->binary_upgrade && privtype == 'e' &&
   16083          26 :         initprivs && *initprivs != '\0')
   16084             :     {
   16085          26 :         appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(true);\n");
   16086          26 :         if (!buildACLCommands(name, subname, nspname, type,
   16087             :                               initprivs, acldefault, owner,
   16088             :                               "", fout->remoteVersion, sql))
   16089           0 :             pg_fatal("could not parse initial ACL list (%s) or default (%s) for object \"%s\" (%s)",
   16090             :                      initprivs, acldefault, name, type);
   16091          26 :         appendPQExpBufferStr(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
   16092             :     }
   16093             : 
   16094             :     /*
   16095             :      * Now figure the GRANT and REVOKE commands needed to get to the object's
   16096             :      * actual current ACL, starting from the initprivs if given, else from the
   16097             :      * object-type-specific default.  Also, while buildACLCommands will assume
   16098             :      * that a NULL/empty acls string means it needn't do anything, what that
   16099             :      * actually represents is the object-type-specific default; so we need to
   16100             :      * substitute the acldefault string to get the right results in that case.
   16101             :      */
   16102       71408 :     if (initprivs && *initprivs != '\0')
   16103             :     {
   16104       67330 :         baseacls = initprivs;
   16105       67330 :         if (acls == NULL || *acls == '\0')
   16106          34 :             acls = acldefault;
   16107             :     }
   16108             :     else
   16109        4078 :         baseacls = acldefault;
   16110             : 
   16111       71408 :     if (!buildACLCommands(name, subname, nspname, type,
   16112             :                           acls, baseacls, owner,
   16113             :                           "", fout->remoteVersion, sql))
   16114           0 :         pg_fatal("could not parse ACL list (%s) or default (%s) for object \"%s\" (%s)",
   16115             :                  acls, baseacls, name, type);
   16116             : 
   16117       71408 :     if (sql->len > 0)
   16118             :     {
   16119        4138 :         PQExpBuffer tagbuf = createPQExpBuffer();
   16120             :         DumpId      aclDeps[2];
   16121        4138 :         int         nDeps = 0;
   16122             : 
   16123        4138 :         if (tag)
   16124           0 :             appendPQExpBufferStr(tagbuf, tag);
   16125        4138 :         else if (subname)
   16126        2368 :             appendPQExpBuffer(tagbuf, "COLUMN %s.%s", name, subname);
   16127             :         else
   16128        1770 :             appendPQExpBuffer(tagbuf, "%s %s", type, name);
   16129             : 
   16130        4138 :         aclDeps[nDeps++] = objDumpId;
   16131        4138 :         if (altDumpId != InvalidDumpId)
   16132        2174 :             aclDeps[nDeps++] = altDumpId;
   16133             : 
   16134        4138 :         aclDumpId = createDumpId();
   16135             : 
   16136        4138 :         ArchiveEntry(fout, nilCatalogId, aclDumpId,
   16137        4138 :                      ARCHIVE_OPTS(.tag = tagbuf->data,
   16138             :                                   .namespace = nspname,
   16139             :                                   .owner = owner,
   16140             :                                   .description = "ACL",
   16141             :                                   .section = SECTION_NONE,
   16142             :                                   .createStmt = sql->data,
   16143             :                                   .deps = aclDeps,
   16144             :                                   .nDeps = nDeps));
   16145             : 
   16146        4138 :         destroyPQExpBuffer(tagbuf);
   16147             :     }
   16148             : 
   16149       71408 :     destroyPQExpBuffer(sql);
   16150             : 
   16151       71408 :     return aclDumpId;
   16152             : }
   16153             : 
   16154             : /*
   16155             :  * dumpSecLabel
   16156             :  *
   16157             :  * This routine is used to dump any security labels associated with the
   16158             :  * object handed to this routine. The routine takes the object type
   16159             :  * and object name (ready to print, except for schema decoration), plus
   16160             :  * the namespace and owner of the object (for labeling the ArchiveEntry),
   16161             :  * plus catalog ID and subid which are the lookup key for pg_seclabel,
   16162             :  * plus the dump ID for the object (for setting a dependency).
   16163             :  * If a matching pg_seclabel entry is found, it is dumped.
   16164             :  *
   16165             :  * Note: although this routine takes a dumpId for dependency purposes,
   16166             :  * that purpose is just to mark the dependency in the emitted dump file
   16167             :  * for possible future use by pg_restore.  We do NOT use it for determining
   16168             :  * ordering of the label in the dump file, because this routine is called
   16169             :  * after dependency sorting occurs.  This routine should be called just after
   16170             :  * calling ArchiveEntry() for the specified object.
   16171             :  */
   16172             : static void
   16173           0 : dumpSecLabel(Archive *fout, const char *type, const char *name,
   16174             :              const char *namespace, const char *owner,
   16175             :              CatalogId catalogId, int subid, DumpId dumpId)
   16176             : {
   16177           0 :     DumpOptions *dopt = fout->dopt;
   16178             :     SecLabelItem *labels;
   16179             :     int         nlabels;
   16180             :     int         i;
   16181             :     PQExpBuffer query;
   16182             : 
   16183             :     /* do nothing, if --no-security-labels is supplied */
   16184           0 :     if (dopt->no_security_labels)
   16185           0 :         return;
   16186             : 
   16187             :     /*
   16188             :      * Security labels are schema not data ... except large object labels are
   16189             :      * data
   16190             :      */
   16191           0 :     if (strcmp(type, "LARGE OBJECT") != 0)
   16192             :     {
   16193           0 :         if (!dopt->dumpSchema)
   16194           0 :             return;
   16195             :     }
   16196             :     else
   16197             :     {
   16198             :         /* We do dump large object security labels in binary-upgrade mode */
   16199           0 :         if (!dopt->dumpData && !dopt->binary_upgrade)
   16200           0 :             return;
   16201             :     }
   16202             : 
   16203             :     /* Search for security labels associated with catalogId, using table */
   16204           0 :     nlabels = findSecLabels(catalogId.tableoid, catalogId.oid, &labels);
   16205             : 
   16206           0 :     query = createPQExpBuffer();
   16207             : 
   16208           0 :     for (i = 0; i < nlabels; i++)
   16209             :     {
   16210             :         /*
   16211             :          * Ignore label entries for which the subid doesn't match.
   16212             :          */
   16213           0 :         if (labels[i].objsubid != subid)
   16214           0 :             continue;
   16215             : 
   16216           0 :         appendPQExpBuffer(query,
   16217             :                           "SECURITY LABEL FOR %s ON %s ",
   16218           0 :                           fmtId(labels[i].provider), type);
   16219           0 :         if (namespace && *namespace)
   16220           0 :             appendPQExpBuffer(query, "%s.", fmtId(namespace));
   16221           0 :         appendPQExpBuffer(query, "%s IS ", name);
   16222           0 :         appendStringLiteralAH(query, labels[i].label, fout);
   16223           0 :         appendPQExpBufferStr(query, ";\n");
   16224             :     }
   16225             : 
   16226           0 :     if (query->len > 0)
   16227             :     {
   16228           0 :         PQExpBuffer tag = createPQExpBuffer();
   16229             : 
   16230           0 :         appendPQExpBuffer(tag, "%s %s", type, name);
   16231           0 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
   16232           0 :                      ARCHIVE_OPTS(.tag = tag->data,
   16233             :                                   .namespace = namespace,
   16234             :                                   .owner = owner,
   16235             :                                   .description = "SECURITY LABEL",
   16236             :                                   .section = SECTION_NONE,
   16237             :                                   .createStmt = query->data,
   16238             :                                   .deps = &dumpId,
   16239             :                                   .nDeps = 1));
   16240           0 :         destroyPQExpBuffer(tag);
   16241             :     }
   16242             : 
   16243           0 :     destroyPQExpBuffer(query);
   16244             : }
   16245             : 
   16246             : /*
   16247             :  * dumpTableSecLabel
   16248             :  *
   16249             :  * As above, but dump security label for both the specified table (or view)
   16250             :  * and its columns.
   16251             :  */
   16252             : static void
   16253           0 : dumpTableSecLabel(Archive *fout, const TableInfo *tbinfo, const char *reltypename)
   16254             : {
   16255           0 :     DumpOptions *dopt = fout->dopt;
   16256             :     SecLabelItem *labels;
   16257             :     int         nlabels;
   16258             :     int         i;
   16259             :     PQExpBuffer query;
   16260             :     PQExpBuffer target;
   16261             : 
   16262             :     /* do nothing, if --no-security-labels is supplied */
   16263           0 :     if (dopt->no_security_labels)
   16264           0 :         return;
   16265             : 
   16266             :     /* SecLabel are SCHEMA not data */
   16267           0 :     if (!dopt->dumpSchema)
   16268           0 :         return;
   16269             : 
   16270             :     /* Search for comments associated with relation, using table */
   16271           0 :     nlabels = findSecLabels(tbinfo->dobj.catId.tableoid,
   16272             :                             tbinfo->dobj.catId.oid,
   16273             :                             &labels);
   16274             : 
   16275             :     /* If security labels exist, build SECURITY LABEL statements */
   16276           0 :     if (nlabels <= 0)
   16277           0 :         return;
   16278             : 
   16279           0 :     query = createPQExpBuffer();
   16280           0 :     target = createPQExpBuffer();
   16281             : 
   16282           0 :     for (i = 0; i < nlabels; i++)
   16283             :     {
   16284             :         const char *colname;
   16285           0 :         const char *provider = labels[i].provider;
   16286           0 :         const char *label = labels[i].label;
   16287           0 :         int         objsubid = labels[i].objsubid;
   16288             : 
   16289           0 :         resetPQExpBuffer(target);
   16290           0 :         if (objsubid == 0)
   16291             :         {
   16292           0 :             appendPQExpBuffer(target, "%s %s", reltypename,
   16293           0 :                               fmtQualifiedDumpable(tbinfo));
   16294             :         }
   16295             :         else
   16296             :         {
   16297           0 :             colname = getAttrName(objsubid, tbinfo);
   16298             :             /* first fmtXXX result must be consumed before calling again */
   16299           0 :             appendPQExpBuffer(target, "COLUMN %s",
   16300           0 :                               fmtQualifiedDumpable(tbinfo));
   16301           0 :             appendPQExpBuffer(target, ".%s", fmtId(colname));
   16302             :         }
   16303           0 :         appendPQExpBuffer(query, "SECURITY LABEL FOR %s ON %s IS ",
   16304             :                           fmtId(provider), target->data);
   16305           0 :         appendStringLiteralAH(query, label, fout);
   16306           0 :         appendPQExpBufferStr(query, ";\n");
   16307             :     }
   16308           0 :     if (query->len > 0)
   16309             :     {
   16310           0 :         resetPQExpBuffer(target);
   16311           0 :         appendPQExpBuffer(target, "%s %s", reltypename,
   16312           0 :                           fmtId(tbinfo->dobj.name));
   16313           0 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
   16314           0 :                      ARCHIVE_OPTS(.tag = target->data,
   16315             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   16316             :                                   .owner = tbinfo->rolname,
   16317             :                                   .description = "SECURITY LABEL",
   16318             :                                   .section = SECTION_NONE,
   16319             :                                   .createStmt = query->data,
   16320             :                                   .deps = &(tbinfo->dobj.dumpId),
   16321             :                                   .nDeps = 1));
   16322             :     }
   16323           0 :     destroyPQExpBuffer(query);
   16324           0 :     destroyPQExpBuffer(target);
   16325             : }
   16326             : 
   16327             : /*
   16328             :  * findSecLabels
   16329             :  *
   16330             :  * Find the security label(s), if any, associated with the given object.
   16331             :  * All the objsubid values associated with the given classoid/objoid are
   16332             :  * found with one search.
   16333             :  */
   16334             : static int
   16335           0 : findSecLabels(Oid classoid, Oid objoid, SecLabelItem **items)
   16336             : {
   16337           0 :     SecLabelItem *middle = NULL;
   16338             :     SecLabelItem *low;
   16339             :     SecLabelItem *high;
   16340             :     int         nmatch;
   16341             : 
   16342           0 :     if (nseclabels <= 0)     /* no labels, so no match is possible */
   16343             :     {
   16344           0 :         *items = NULL;
   16345           0 :         return 0;
   16346             :     }
   16347             : 
   16348             :     /*
   16349             :      * Do binary search to find some item matching the object.
   16350             :      */
   16351           0 :     low = &seclabels[0];
   16352           0 :     high = &seclabels[nseclabels - 1];
   16353           0 :     while (low <= high)
   16354             :     {
   16355           0 :         middle = low + (high - low) / 2;
   16356             : 
   16357           0 :         if (classoid < middle->classoid)
   16358           0 :             high = middle - 1;
   16359           0 :         else if (classoid > middle->classoid)
   16360           0 :             low = middle + 1;
   16361           0 :         else if (objoid < middle->objoid)
   16362           0 :             high = middle - 1;
   16363           0 :         else if (objoid > middle->objoid)
   16364           0 :             low = middle + 1;
   16365             :         else
   16366           0 :             break;              /* found a match */
   16367             :     }
   16368             : 
   16369           0 :     if (low > high)              /* no matches */
   16370             :     {
   16371           0 :         *items = NULL;
   16372           0 :         return 0;
   16373             :     }
   16374             : 
   16375             :     /*
   16376             :      * Now determine how many items match the object.  The search loop
   16377             :      * invariant still holds: only items between low and high inclusive could
   16378             :      * match.
   16379             :      */
   16380           0 :     nmatch = 1;
   16381           0 :     while (middle > low)
   16382             :     {
   16383           0 :         if (classoid != middle[-1].classoid ||
   16384           0 :             objoid != middle[-1].objoid)
   16385             :             break;
   16386           0 :         middle--;
   16387           0 :         nmatch++;
   16388             :     }
   16389             : 
   16390           0 :     *items = middle;
   16391             : 
   16392           0 :     middle += nmatch;
   16393           0 :     while (middle <= high)
   16394             :     {
   16395           0 :         if (classoid != middle->classoid ||
   16396           0 :             objoid != middle->objoid)
   16397             :             break;
   16398           0 :         middle++;
   16399           0 :         nmatch++;
   16400             :     }
   16401             : 
   16402           0 :     return nmatch;
   16403             : }
   16404             : 
   16405             : /*
   16406             :  * collectSecLabels
   16407             :  *
   16408             :  * Construct a table of all security labels available for database objects;
   16409             :  * also set the has-seclabel component flag for each relevant object.
   16410             :  *
   16411             :  * The table is sorted by classoid/objid/objsubid for speed in lookup.
   16412             :  */
   16413             : static void
   16414         468 : collectSecLabels(Archive *fout)
   16415             : {
   16416             :     PGresult   *res;
   16417             :     PQExpBuffer query;
   16418             :     int         i_label;
   16419             :     int         i_provider;
   16420             :     int         i_classoid;
   16421             :     int         i_objoid;
   16422             :     int         i_objsubid;
   16423             :     int         ntups;
   16424             :     int         i;
   16425             :     DumpableObject *dobj;
   16426             : 
   16427         468 :     query = createPQExpBuffer();
   16428             : 
   16429         468 :     appendPQExpBufferStr(query,
   16430             :                          "SELECT label, provider, classoid, objoid, objsubid "
   16431             :                          "FROM pg_catalog.pg_seclabel "
   16432             :                          "ORDER BY classoid, objoid, objsubid");
   16433             : 
   16434         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   16435             : 
   16436             :     /* Construct lookup table containing OIDs in numeric form */
   16437         468 :     i_label = PQfnumber(res, "label");
   16438         468 :     i_provider = PQfnumber(res, "provider");
   16439         468 :     i_classoid = PQfnumber(res, "classoid");
   16440         468 :     i_objoid = PQfnumber(res, "objoid");
   16441         468 :     i_objsubid = PQfnumber(res, "objsubid");
   16442             : 
   16443         468 :     ntups = PQntuples(res);
   16444             : 
   16445         468 :     seclabels = (SecLabelItem *) pg_malloc(ntups * sizeof(SecLabelItem));
   16446         468 :     nseclabels = 0;
   16447         468 :     dobj = NULL;
   16448             : 
   16449         468 :     for (i = 0; i < ntups; i++)
   16450             :     {
   16451             :         CatalogId   objId;
   16452             :         int         subid;
   16453             : 
   16454           0 :         objId.tableoid = atooid(PQgetvalue(res, i, i_classoid));
   16455           0 :         objId.oid = atooid(PQgetvalue(res, i, i_objoid));
   16456           0 :         subid = atoi(PQgetvalue(res, i, i_objsubid));
   16457             : 
   16458             :         /* We needn't remember labels that don't match any dumpable object */
   16459           0 :         if (dobj == NULL ||
   16460           0 :             dobj->catId.tableoid != objId.tableoid ||
   16461           0 :             dobj->catId.oid != objId.oid)
   16462           0 :             dobj = findObjectByCatalogId(objId);
   16463           0 :         if (dobj == NULL)
   16464           0 :             continue;
   16465             : 
   16466             :         /*
   16467             :          * Labels on columns of composite types are linked to the type's
   16468             :          * pg_class entry, but we need to set the DUMP_COMPONENT_SECLABEL flag
   16469             :          * in the type's own DumpableObject.
   16470             :          */
   16471           0 :         if (subid != 0 && dobj->objType == DO_TABLE &&
   16472           0 :             ((TableInfo *) dobj)->relkind == RELKIND_COMPOSITE_TYPE)
   16473           0 :         {
   16474             :             TypeInfo   *cTypeInfo;
   16475             : 
   16476           0 :             cTypeInfo = findTypeByOid(((TableInfo *) dobj)->reltype);
   16477           0 :             if (cTypeInfo)
   16478           0 :                 cTypeInfo->dobj.components |= DUMP_COMPONENT_SECLABEL;
   16479             :         }
   16480             :         else
   16481           0 :             dobj->components |= DUMP_COMPONENT_SECLABEL;
   16482             : 
   16483           0 :         seclabels[nseclabels].label = pg_strdup(PQgetvalue(res, i, i_label));
   16484           0 :         seclabels[nseclabels].provider = pg_strdup(PQgetvalue(res, i, i_provider));
   16485           0 :         seclabels[nseclabels].classoid = objId.tableoid;
   16486           0 :         seclabels[nseclabels].objoid = objId.oid;
   16487           0 :         seclabels[nseclabels].objsubid = subid;
   16488           0 :         nseclabels++;
   16489             :     }
   16490             : 
   16491         468 :     PQclear(res);
   16492         468 :     destroyPQExpBuffer(query);
   16493         468 : }
   16494             : 
   16495             : /*
   16496             :  * dumpTable
   16497             :  *    write out to fout the declarations (not data) of a user-defined table
   16498             :  */
   16499             : static void
   16500       80208 : dumpTable(Archive *fout, const TableInfo *tbinfo)
   16501             : {
   16502       80208 :     DumpOptions *dopt = fout->dopt;
   16503       80208 :     DumpId      tableAclDumpId = InvalidDumpId;
   16504             :     char       *namecopy;
   16505             : 
   16506             :     /* Do nothing if not dumping schema */
   16507       80208 :     if (!dopt->dumpSchema)
   16508        2936 :         return;
   16509             : 
   16510       77272 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   16511             :     {
   16512       18214 :         if (tbinfo->relkind == RELKIND_SEQUENCE)
   16513        1106 :             dumpSequence(fout, tbinfo);
   16514             :         else
   16515       17108 :             dumpTableSchema(fout, tbinfo);
   16516             :     }
   16517             : 
   16518             :     /* Handle the ACL here */
   16519       77272 :     namecopy = pg_strdup(fmtId(tbinfo->dobj.name));
   16520       77272 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_ACL)
   16521             :     {
   16522       60626 :         const char *objtype =
   16523       60626 :             (tbinfo->relkind == RELKIND_SEQUENCE) ? "SEQUENCE" : "TABLE";
   16524             : 
   16525             :         tableAclDumpId =
   16526       60626 :             dumpACL(fout, tbinfo->dobj.dumpId, InvalidDumpId,
   16527             :                     objtype, namecopy, NULL,
   16528       60626 :                     tbinfo->dobj.namespace->dobj.name,
   16529             :                     NULL, tbinfo->rolname, &tbinfo->dacl);
   16530             :     }
   16531             : 
   16532             :     /*
   16533             :      * Handle column ACLs, if any.  Note: we pull these with a separate query
   16534             :      * rather than trying to fetch them during getTableAttrs, so that we won't
   16535             :      * miss ACLs on system columns.  Doing it this way also allows us to dump
   16536             :      * ACLs for catalogs that we didn't mark "interesting" back in getTables.
   16537             :      */
   16538       77272 :     if ((tbinfo->dobj.dump & DUMP_COMPONENT_ACL) && tbinfo->hascolumnACLs)
   16539             :     {
   16540         694 :         PQExpBuffer query = createPQExpBuffer();
   16541             :         PGresult   *res;
   16542             :         int         i;
   16543             : 
   16544         694 :         if (!fout->is_prepared[PREPQUERY_GETCOLUMNACLS])
   16545             :         {
   16546             :             /* Set up query for column ACLs */
   16547         416 :             appendPQExpBufferStr(query,
   16548             :                                  "PREPARE getColumnACLs(pg_catalog.oid) AS\n");
   16549             : 
   16550         416 :             if (fout->remoteVersion >= 90600)
   16551             :             {
   16552             :                 /*
   16553             :                  * In principle we should call acldefault('c', relowner) to
   16554             :                  * get the default ACL for a column.  However, we don't
   16555             :                  * currently store the numeric OID of the relowner in
   16556             :                  * TableInfo.  We could convert the owner name using regrole,
   16557             :                  * but that creates a risk of failure due to concurrent role
   16558             :                  * renames.  Given that the default ACL for columns is empty
   16559             :                  * and is likely to stay that way, it's not worth extra cycles
   16560             :                  * and risk to avoid hard-wiring that knowledge here.
   16561             :                  */
   16562         416 :                 appendPQExpBufferStr(query,
   16563             :                                      "SELECT at.attname, "
   16564             :                                      "at.attacl, "
   16565             :                                      "'{}' AS acldefault, "
   16566             :                                      "pip.privtype, pip.initprivs "
   16567             :                                      "FROM pg_catalog.pg_attribute at "
   16568             :                                      "LEFT JOIN pg_catalog.pg_init_privs pip ON "
   16569             :                                      "(at.attrelid = pip.objoid "
   16570             :                                      "AND pip.classoid = 'pg_catalog.pg_class'::pg_catalog.regclass "
   16571             :                                      "AND at.attnum = pip.objsubid) "
   16572             :                                      "WHERE at.attrelid = $1 AND "
   16573             :                                      "NOT at.attisdropped "
   16574             :                                      "AND (at.attacl IS NOT NULL OR pip.initprivs IS NOT NULL) "
   16575             :                                      "ORDER BY at.attnum");
   16576             :             }
   16577             :             else
   16578             :             {
   16579           0 :                 appendPQExpBufferStr(query,
   16580             :                                      "SELECT attname, attacl, '{}' AS acldefault, "
   16581             :                                      "NULL AS privtype, NULL AS initprivs "
   16582             :                                      "FROM pg_catalog.pg_attribute "
   16583             :                                      "WHERE attrelid = $1 AND NOT attisdropped "
   16584             :                                      "AND attacl IS NOT NULL "
   16585             :                                      "ORDER BY attnum");
   16586             :             }
   16587             : 
   16588         416 :             ExecuteSqlStatement(fout, query->data);
   16589             : 
   16590         416 :             fout->is_prepared[PREPQUERY_GETCOLUMNACLS] = true;
   16591             :         }
   16592             : 
   16593         694 :         printfPQExpBuffer(query,
   16594             :                           "EXECUTE getColumnACLs('%u')",
   16595             :                           tbinfo->dobj.catId.oid);
   16596             : 
   16597         694 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   16598             : 
   16599       10032 :         for (i = 0; i < PQntuples(res); i++)
   16600             :         {
   16601        9338 :             char       *attname = PQgetvalue(res, i, 0);
   16602        9338 :             char       *attacl = PQgetvalue(res, i, 1);
   16603        9338 :             char       *acldefault = PQgetvalue(res, i, 2);
   16604        9338 :             char        privtype = *(PQgetvalue(res, i, 3));
   16605        9338 :             char       *initprivs = PQgetvalue(res, i, 4);
   16606             :             DumpableAcl coldacl;
   16607             :             char       *attnamecopy;
   16608             : 
   16609        9338 :             coldacl.acl = attacl;
   16610        9338 :             coldacl.acldefault = acldefault;
   16611        9338 :             coldacl.privtype = privtype;
   16612        9338 :             coldacl.initprivs = initprivs;
   16613        9338 :             attnamecopy = pg_strdup(fmtId(attname));
   16614             : 
   16615             :             /*
   16616             :              * Column's GRANT type is always TABLE.  Each column ACL depends
   16617             :              * on the table-level ACL, since we can restore column ACLs in
   16618             :              * parallel but the table-level ACL has to be done first.
   16619             :              */
   16620        9338 :             dumpACL(fout, tbinfo->dobj.dumpId, tableAclDumpId,
   16621             :                     "TABLE", namecopy, attnamecopy,
   16622        9338 :                     tbinfo->dobj.namespace->dobj.name,
   16623             :                     NULL, tbinfo->rolname, &coldacl);
   16624        9338 :             free(attnamecopy);
   16625             :         }
   16626         694 :         PQclear(res);
   16627         694 :         destroyPQExpBuffer(query);
   16628             :     }
   16629             : 
   16630       77272 :     free(namecopy);
   16631             : }
   16632             : 
   16633             : /*
   16634             :  * Create the AS clause for a view or materialized view. The semicolon is
   16635             :  * stripped because a materialized view must add a WITH NO DATA clause.
   16636             :  *
   16637             :  * This returns a new buffer which must be freed by the caller.
   16638             :  */
   16639             : static PQExpBuffer
   16640        2200 : createViewAsClause(Archive *fout, const TableInfo *tbinfo)
   16641             : {
   16642        2200 :     PQExpBuffer query = createPQExpBuffer();
   16643        2200 :     PQExpBuffer result = createPQExpBuffer();
   16644             :     PGresult   *res;
   16645             :     int         len;
   16646             : 
   16647             :     /* Fetch the view definition */
   16648        2200 :     appendPQExpBuffer(query,
   16649             :                       "SELECT pg_catalog.pg_get_viewdef('%u'::pg_catalog.oid) AS viewdef",
   16650             :                       tbinfo->dobj.catId.oid);
   16651             : 
   16652        2200 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   16653             : 
   16654        2200 :     if (PQntuples(res) != 1)
   16655             :     {
   16656           0 :         if (PQntuples(res) < 1)
   16657           0 :             pg_fatal("query to obtain definition of view \"%s\" returned no data",
   16658             :                      tbinfo->dobj.name);
   16659             :         else
   16660           0 :             pg_fatal("query to obtain definition of view \"%s\" returned more than one definition",
   16661             :                      tbinfo->dobj.name);
   16662             :     }
   16663             : 
   16664        2200 :     len = PQgetlength(res, 0, 0);
   16665             : 
   16666        2200 :     if (len == 0)
   16667           0 :         pg_fatal("definition of view \"%s\" appears to be empty (length zero)",
   16668             :                  tbinfo->dobj.name);
   16669             : 
   16670             :     /* Strip off the trailing semicolon so that other things may follow. */
   16671             :     Assert(PQgetvalue(res, 0, 0)[len - 1] == ';');
   16672        2200 :     appendBinaryPQExpBuffer(result, PQgetvalue(res, 0, 0), len - 1);
   16673             : 
   16674        2200 :     PQclear(res);
   16675        2200 :     destroyPQExpBuffer(query);
   16676             : 
   16677        2200 :     return result;
   16678             : }
   16679             : 
   16680             : /*
   16681             :  * Create a dummy AS clause for a view.  This is used when the real view
   16682             :  * definition has to be postponed because of circular dependencies.
   16683             :  * We must duplicate the view's external properties -- column names and types
   16684             :  * (including collation) -- so that it works for subsequent references.
   16685             :  *
   16686             :  * This returns a new buffer which must be freed by the caller.
   16687             :  */
   16688             : static PQExpBuffer
   16689          64 : createDummyViewAsClause(Archive *fout, const TableInfo *tbinfo)
   16690             : {
   16691          64 :     PQExpBuffer result = createPQExpBuffer();
   16692             :     int         j;
   16693             : 
   16694          64 :     appendPQExpBufferStr(result, "SELECT");
   16695             : 
   16696         128 :     for (j = 0; j < tbinfo->numatts; j++)
   16697             :     {
   16698          64 :         if (j > 0)
   16699          32 :             appendPQExpBufferChar(result, ',');
   16700          64 :         appendPQExpBufferStr(result, "\n    ");
   16701             : 
   16702          64 :         appendPQExpBuffer(result, "NULL::%s", tbinfo->atttypnames[j]);
   16703             : 
   16704             :         /*
   16705             :          * Must add collation if not default for the type, because CREATE OR
   16706             :          * REPLACE VIEW won't change it
   16707             :          */
   16708          64 :         if (OidIsValid(tbinfo->attcollation[j]))
   16709             :         {
   16710             :             CollInfo   *coll;
   16711             : 
   16712           0 :             coll = findCollationByOid(tbinfo->attcollation[j]);
   16713           0 :             if (coll)
   16714           0 :                 appendPQExpBuffer(result, " COLLATE %s",
   16715           0 :                                   fmtQualifiedDumpable(coll));
   16716             :         }
   16717             : 
   16718          64 :         appendPQExpBuffer(result, " AS %s", fmtId(tbinfo->attnames[j]));
   16719             :     }
   16720             : 
   16721          64 :     return result;
   16722             : }
   16723             : 
   16724             : /*
   16725             :  * dumpTableSchema
   16726             :  *    write the declaration (not data) of one user-defined table or view
   16727             :  */
   16728             : static void
   16729       17108 : dumpTableSchema(Archive *fout, const TableInfo *tbinfo)
   16730             : {
   16731       17108 :     DumpOptions *dopt = fout->dopt;
   16732       17108 :     PQExpBuffer q = createPQExpBuffer();
   16733       17108 :     PQExpBuffer delq = createPQExpBuffer();
   16734       17108 :     PQExpBuffer extra = createPQExpBuffer();
   16735             :     char       *qrelname;
   16736             :     char       *qualrelname;
   16737             :     int         numParents;
   16738             :     TableInfo **parents;
   16739             :     int         actual_atts;    /* number of attrs in this CREATE statement */
   16740             :     const char *reltypename;
   16741             :     char       *storage;
   16742             :     int         j,
   16743             :                 k;
   16744             : 
   16745             :     /* We had better have loaded per-column details about this table */
   16746             :     Assert(tbinfo->interesting);
   16747             : 
   16748       17108 :     qrelname = pg_strdup(fmtId(tbinfo->dobj.name));
   16749       17108 :     qualrelname = pg_strdup(fmtQualifiedDumpable(tbinfo));
   16750             : 
   16751       17108 :     if (tbinfo->hasoids)
   16752           0 :         pg_log_warning("WITH OIDS is not supported anymore (table \"%s\")",
   16753             :                        qrelname);
   16754             : 
   16755       17108 :     if (dopt->binary_upgrade)
   16756        1670 :         binary_upgrade_set_type_oids_by_rel(fout, q, tbinfo);
   16757             : 
   16758             :     /* Is it a table or a view? */
   16759       17108 :     if (tbinfo->relkind == RELKIND_VIEW)
   16760             :     {
   16761             :         PQExpBuffer result;
   16762             : 
   16763             :         /*
   16764             :          * Note: keep this code in sync with the is_view case in dumpRule()
   16765             :          */
   16766             : 
   16767        1352 :         reltypename = "VIEW";
   16768             : 
   16769        1352 :         appendPQExpBuffer(delq, "DROP VIEW %s;\n", qualrelname);
   16770             : 
   16771        1352 :         if (dopt->binary_upgrade)
   16772         102 :             binary_upgrade_set_pg_class_oids(fout, q,
   16773             :                                              tbinfo->dobj.catId.oid);
   16774             : 
   16775        1352 :         appendPQExpBuffer(q, "CREATE VIEW %s", qualrelname);
   16776             : 
   16777        1352 :         if (tbinfo->dummy_view)
   16778          32 :             result = createDummyViewAsClause(fout, tbinfo);
   16779             :         else
   16780             :         {
   16781        1320 :             if (nonemptyReloptions(tbinfo->reloptions))
   16782             :             {
   16783         154 :                 appendPQExpBufferStr(q, " WITH (");
   16784         154 :                 appendReloptionsArrayAH(q, tbinfo->reloptions, "", fout);
   16785         154 :                 appendPQExpBufferChar(q, ')');
   16786             :             }
   16787        1320 :             result = createViewAsClause(fout, tbinfo);
   16788             :         }
   16789        1352 :         appendPQExpBuffer(q, " AS\n%s", result->data);
   16790        1352 :         destroyPQExpBuffer(result);
   16791             : 
   16792        1352 :         if (tbinfo->checkoption != NULL && !tbinfo->dummy_view)
   16793          72 :             appendPQExpBuffer(q, "\n  WITH %s CHECK OPTION", tbinfo->checkoption);
   16794        1352 :         appendPQExpBufferStr(q, ";\n");
   16795             :     }
   16796             :     else
   16797             :     {
   16798       15756 :         char       *partkeydef = NULL;
   16799       15756 :         char       *ftoptions = NULL;
   16800       15756 :         char       *srvname = NULL;
   16801       15756 :         const char *foreign = "";
   16802             : 
   16803             :         /*
   16804             :          * Set reltypename, and collect any relkind-specific data that we
   16805             :          * didn't fetch during getTables().
   16806             :          */
   16807       15756 :         switch (tbinfo->relkind)
   16808             :         {
   16809        1616 :             case RELKIND_PARTITIONED_TABLE:
   16810             :                 {
   16811        1616 :                     PQExpBuffer query = createPQExpBuffer();
   16812             :                     PGresult   *res;
   16813             : 
   16814        1616 :                     reltypename = "TABLE";
   16815             : 
   16816             :                     /* retrieve partition key definition */
   16817        1616 :                     appendPQExpBuffer(query,
   16818             :                                       "SELECT pg_get_partkeydef('%u')",
   16819             :                                       tbinfo->dobj.catId.oid);
   16820        1616 :                     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   16821        1616 :                     partkeydef = pg_strdup(PQgetvalue(res, 0, 0));
   16822        1616 :                     PQclear(res);
   16823        1616 :                     destroyPQExpBuffer(query);
   16824        1616 :                     break;
   16825             :                 }
   16826          76 :             case RELKIND_FOREIGN_TABLE:
   16827             :                 {
   16828          76 :                     PQExpBuffer query = createPQExpBuffer();
   16829             :                     PGresult   *res;
   16830             :                     int         i_srvname;
   16831             :                     int         i_ftoptions;
   16832             : 
   16833          76 :                     reltypename = "FOREIGN TABLE";
   16834             : 
   16835             :                     /* retrieve name of foreign server and generic options */
   16836          76 :                     appendPQExpBuffer(query,
   16837             :                                       "SELECT fs.srvname, "
   16838             :                                       "pg_catalog.array_to_string(ARRAY("
   16839             :                                       "SELECT pg_catalog.quote_ident(option_name) || "
   16840             :                                       "' ' || pg_catalog.quote_literal(option_value) "
   16841             :                                       "FROM pg_catalog.pg_options_to_table(ftoptions) "
   16842             :                                       "ORDER BY option_name"
   16843             :                                       "), E',\n    ') AS ftoptions "
   16844             :                                       "FROM pg_catalog.pg_foreign_table ft "
   16845             :                                       "JOIN pg_catalog.pg_foreign_server fs "
   16846             :                                       "ON (fs.oid = ft.ftserver) "
   16847             :                                       "WHERE ft.ftrelid = '%u'",
   16848             :                                       tbinfo->dobj.catId.oid);
   16849          76 :                     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   16850          76 :                     i_srvname = PQfnumber(res, "srvname");
   16851          76 :                     i_ftoptions = PQfnumber(res, "ftoptions");
   16852          76 :                     srvname = pg_strdup(PQgetvalue(res, 0, i_srvname));
   16853          76 :                     ftoptions = pg_strdup(PQgetvalue(res, 0, i_ftoptions));
   16854          76 :                     PQclear(res);
   16855          76 :                     destroyPQExpBuffer(query);
   16856             : 
   16857          76 :                     foreign = "FOREIGN ";
   16858          76 :                     break;
   16859             :                 }
   16860         848 :             case RELKIND_MATVIEW:
   16861         848 :                 reltypename = "MATERIALIZED VIEW";
   16862         848 :                 break;
   16863       13216 :             default:
   16864       13216 :                 reltypename = "TABLE";
   16865       13216 :                 break;
   16866             :         }
   16867             : 
   16868       15756 :         numParents = tbinfo->numParents;
   16869       15756 :         parents = tbinfo->parents;
   16870             : 
   16871       15756 :         appendPQExpBuffer(delq, "DROP %s %s;\n", reltypename, qualrelname);
   16872             : 
   16873       15756 :         if (dopt->binary_upgrade)
   16874        1568 :             binary_upgrade_set_pg_class_oids(fout, q,
   16875             :                                              tbinfo->dobj.catId.oid);
   16876             : 
   16877             :         /*
   16878             :          * PostgreSQL 18 has disabled UNLOGGED for partitioned tables, so
   16879             :          * ignore it when dumping if it was set in this case.
   16880             :          */
   16881       15756 :         appendPQExpBuffer(q, "CREATE %s%s %s",
   16882       15756 :                           (tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED &&
   16883          64 :                            tbinfo->relkind != RELKIND_PARTITIONED_TABLE) ?
   16884             :                           "UNLOGGED " : "",
   16885             :                           reltypename,
   16886             :                           qualrelname);
   16887             : 
   16888             :         /*
   16889             :          * Attach to type, if reloftype; except in case of a binary upgrade,
   16890             :          * we dump the table normally and attach it to the type afterward.
   16891             :          */
   16892       15756 :         if (OidIsValid(tbinfo->reloftype) && !dopt->binary_upgrade)
   16893          84 :             appendPQExpBuffer(q, " OF %s",
   16894             :                               getFormattedTypeName(fout, tbinfo->reloftype,
   16895             :                                                    zeroIsError));
   16896             : 
   16897       15756 :         if (tbinfo->relkind != RELKIND_MATVIEW)
   16898             :         {
   16899             :             /* Dump the attributes */
   16900       14908 :             actual_atts = 0;
   16901       72522 :             for (j = 0; j < tbinfo->numatts; j++)
   16902             :             {
   16903             :                 /*
   16904             :                  * Normally, dump if it's locally defined in this table, and
   16905             :                  * not dropped.  But for binary upgrade, we'll dump all the
   16906             :                  * columns, and then fix up the dropped and nonlocal cases
   16907             :                  * below.
   16908             :                  */
   16909       57614 :                 if (shouldPrintColumn(dopt, tbinfo, j))
   16910             :                 {
   16911             :                     bool        print_default;
   16912             :                     bool        print_notnull;
   16913             : 
   16914             :                     /*
   16915             :                      * Default value --- suppress if to be printed separately
   16916             :                      * or not at all.
   16917             :                      */
   16918      112648 :                     print_default = (tbinfo->attrdefs[j] != NULL &&
   16919       57668 :                                      tbinfo->attrdefs[j]->dobj.dump &&
   16920        2814 :                                      !tbinfo->attrdefs[j]->separate);
   16921             : 
   16922             :                     /*
   16923             :                      * Not Null constraint --- print it if it is locally
   16924             :                      * defined, or if binary upgrade.  (In the latter case, we
   16925             :                      * reset conislocal below.)
   16926             :                      */
   16927       60694 :                     print_notnull = (tbinfo->notnull_constrs[j] != NULL &&
   16928        5840 :                                      (tbinfo->notnull_islocal[j] ||
   16929        1678 :                                       dopt->binary_upgrade ||
   16930        1508 :                                       tbinfo->ispartition));
   16931             : 
   16932             :                     /*
   16933             :                      * Skip column if fully defined by reloftype, except in
   16934             :                      * binary upgrade
   16935             :                      */
   16936       54854 :                     if (OidIsValid(tbinfo->reloftype) &&
   16937         160 :                         !print_default && !print_notnull &&
   16938          96 :                         !dopt->binary_upgrade)
   16939          84 :                         continue;
   16940             : 
   16941             :                     /* Format properly if not first attr */
   16942       54770 :                     if (actual_atts == 0)
   16943       14218 :                         appendPQExpBufferStr(q, " (");
   16944             :                     else
   16945       40552 :                         appendPQExpBufferChar(q, ',');
   16946       54770 :                     appendPQExpBufferStr(q, "\n    ");
   16947       54770 :                     actual_atts++;
   16948             : 
   16949             :                     /* Attribute name */
   16950       54770 :                     appendPQExpBufferStr(q, fmtId(tbinfo->attnames[j]));
   16951             : 
   16952       54770 :                     if (tbinfo->attisdropped[j])
   16953             :                     {
   16954             :                         /*
   16955             :                          * ALTER TABLE DROP COLUMN clears
   16956             :                          * pg_attribute.atttypid, so we will not have gotten a
   16957             :                          * valid type name; insert INTEGER as a stopgap. We'll
   16958             :                          * clean things up later.
   16959             :                          */
   16960         168 :                         appendPQExpBufferStr(q, " INTEGER /* dummy */");
   16961             :                         /* and skip to the next column */
   16962         168 :                         continue;
   16963             :                     }
   16964             : 
   16965             :                     /*
   16966             :                      * Attribute type; print it except when creating a typed
   16967             :                      * table ('OF type_name'), but in binary-upgrade mode,
   16968             :                      * print it in that case too.
   16969             :                      */
   16970       54602 :                     if (dopt->binary_upgrade || !OidIsValid(tbinfo->reloftype))
   16971             :                     {
   16972       54546 :                         appendPQExpBuffer(q, " %s",
   16973       54546 :                                           tbinfo->atttypnames[j]);
   16974             :                     }
   16975             : 
   16976       54602 :                     if (print_default)
   16977             :                     {
   16978        2460 :                         if (tbinfo->attgenerated[j] == ATTRIBUTE_GENERATED_STORED)
   16979         788 :                             appendPQExpBuffer(q, " GENERATED ALWAYS AS (%s) STORED",
   16980         788 :                                               tbinfo->attrdefs[j]->adef_expr);
   16981        1672 :                         else if (tbinfo->attgenerated[j] == ATTRIBUTE_GENERATED_VIRTUAL)
   16982         660 :                             appendPQExpBuffer(q, " GENERATED ALWAYS AS (%s)",
   16983         660 :                                               tbinfo->attrdefs[j]->adef_expr);
   16984             :                         else
   16985        1012 :                             appendPQExpBuffer(q, " DEFAULT %s",
   16986        1012 :                                               tbinfo->attrdefs[j]->adef_expr);
   16987             :                     }
   16988             : 
   16989       54602 :                     if (print_notnull)
   16990             :                     {
   16991        5770 :                         if (tbinfo->notnull_constrs[j][0] == '\0')
   16992        4148 :                             appendPQExpBufferStr(q, " NOT NULL");
   16993             :                         else
   16994        1622 :                             appendPQExpBuffer(q, " CONSTRAINT %s NOT NULL",
   16995        1622 :                                               fmtId(tbinfo->notnull_constrs[j]));
   16996             : 
   16997        5770 :                         if (tbinfo->notnull_noinh[j])
   16998           0 :                             appendPQExpBufferStr(q, " NO INHERIT");
   16999             :                     }
   17000             : 
   17001             :                     /* Add collation if not default for the type */
   17002       54602 :                     if (OidIsValid(tbinfo->attcollation[j]))
   17003             :                     {
   17004             :                         CollInfo   *coll;
   17005             : 
   17006         400 :                         coll = findCollationByOid(tbinfo->attcollation[j]);
   17007         400 :                         if (coll)
   17008         400 :                             appendPQExpBuffer(q, " COLLATE %s",
   17009         400 :                                               fmtQualifiedDumpable(coll));
   17010             :                     }
   17011             :                 }
   17012             : 
   17013             :                 /*
   17014             :                  * On the other hand, if we choose not to print a column
   17015             :                  * (likely because it is created by inheritance), but the
   17016             :                  * column has a locally-defined not-null constraint, we need
   17017             :                  * to dump the constraint as a standalone object.
   17018             :                  *
   17019             :                  * This syntax isn't SQL-conforming, but if you wanted
   17020             :                  * standard output you wouldn't be creating non-standard
   17021             :                  * objects to begin with.
   17022             :                  */
   17023       57362 :                 if (!shouldPrintColumn(dopt, tbinfo, j) &&
   17024        2760 :                     !tbinfo->attisdropped[j] &&
   17025        1694 :                     tbinfo->notnull_constrs[j] != NULL &&
   17026         322 :                     tbinfo->notnull_islocal[j])
   17027             :                 {
   17028             :                     /* Format properly if not first attr */
   17029          70 :                     if (actual_atts == 0)
   17030          56 :                         appendPQExpBufferStr(q, " (");
   17031             :                     else
   17032          14 :                         appendPQExpBufferChar(q, ',');
   17033          70 :                     appendPQExpBufferStr(q, "\n    ");
   17034          70 :                     actual_atts++;
   17035             : 
   17036          70 :                     if (tbinfo->notnull_constrs[j][0] == '\0')
   17037          14 :                         appendPQExpBuffer(q, "NOT NULL %s",
   17038          14 :                                           fmtId(tbinfo->attnames[j]));
   17039             :                     else
   17040         112 :                         appendPQExpBuffer(q, "CONSTRAINT %s NOT NULL %s",
   17041          56 :                                           tbinfo->notnull_constrs[j],
   17042          56 :                                           fmtId(tbinfo->attnames[j]));
   17043             :                 }
   17044             :             }
   17045             : 
   17046             :             /*
   17047             :              * Add non-inherited CHECK constraints, if any.
   17048             :              *
   17049             :              * For partitions, we need to include check constraints even if
   17050             :              * they're not defined locally, because the ALTER TABLE ATTACH
   17051             :              * PARTITION that we'll emit later expects the constraint to be
   17052             :              * there.  (No need to fix conislocal: ATTACH PARTITION does that)
   17053             :              */
   17054       16460 :             for (j = 0; j < tbinfo->ncheck; j++)
   17055             :             {
   17056        1552 :                 ConstraintInfo *constr = &(tbinfo->checkexprs[j]);
   17057             : 
   17058        1552 :                 if (constr->separate ||
   17059        1328 :                     (!constr->conislocal && !tbinfo->ispartition))
   17060         312 :                     continue;
   17061             : 
   17062        1240 :                 if (actual_atts == 0)
   17063          56 :                     appendPQExpBufferStr(q, " (\n    ");
   17064             :                 else
   17065        1184 :                     appendPQExpBufferStr(q, ",\n    ");
   17066             : 
   17067        1240 :                 appendPQExpBuffer(q, "CONSTRAINT %s ",
   17068        1240 :                                   fmtId(constr->dobj.name));
   17069        1240 :                 appendPQExpBufferStr(q, constr->condef);
   17070             : 
   17071        1240 :                 actual_atts++;
   17072             :             }
   17073             : 
   17074       14908 :             if (actual_atts)
   17075       14330 :                 appendPQExpBufferStr(q, "\n)");
   17076         578 :             else if (!(OidIsValid(tbinfo->reloftype) && !dopt->binary_upgrade))
   17077             :             {
   17078             :                 /*
   17079             :                  * No attributes? we must have a parenthesized attribute list,
   17080             :                  * even though empty, when not using the OF TYPE syntax.
   17081             :                  */
   17082         536 :                 appendPQExpBufferStr(q, " (\n)");
   17083             :             }
   17084             : 
   17085             :             /*
   17086             :              * Emit the INHERITS clause (not for partitions), except in
   17087             :              * binary-upgrade mode.
   17088             :              */
   17089       14908 :             if (numParents > 0 && !tbinfo->ispartition &&
   17090        1078 :                 !dopt->binary_upgrade)
   17091             :             {
   17092         966 :                 appendPQExpBufferStr(q, "\nINHERITS (");
   17093        2044 :                 for (k = 0; k < numParents; k++)
   17094             :                 {
   17095        1078 :                     TableInfo  *parentRel = parents[k];
   17096             : 
   17097        1078 :                     if (k > 0)
   17098         112 :                         appendPQExpBufferStr(q, ", ");
   17099        1078 :                     appendPQExpBufferStr(q, fmtQualifiedDumpable(parentRel));
   17100             :                 }
   17101         966 :                 appendPQExpBufferChar(q, ')');
   17102             :             }
   17103             : 
   17104       14908 :             if (tbinfo->relkind == RELKIND_PARTITIONED_TABLE)
   17105        1616 :                 appendPQExpBuffer(q, "\nPARTITION BY %s", partkeydef);
   17106             : 
   17107       14908 :             if (tbinfo->relkind == RELKIND_FOREIGN_TABLE)
   17108          76 :                 appendPQExpBuffer(q, "\nSERVER %s", fmtId(srvname));
   17109             :         }
   17110             : 
   17111       31088 :         if (nonemptyReloptions(tbinfo->reloptions) ||
   17112       15332 :             nonemptyReloptions(tbinfo->toast_reloptions))
   17113             :         {
   17114         424 :             bool        addcomma = false;
   17115             : 
   17116         424 :             appendPQExpBufferStr(q, "\nWITH (");
   17117         424 :             if (nonemptyReloptions(tbinfo->reloptions))
   17118             :             {
   17119         424 :                 addcomma = true;
   17120         424 :                 appendReloptionsArrayAH(q, tbinfo->reloptions, "", fout);
   17121             :             }
   17122         424 :             if (nonemptyReloptions(tbinfo->toast_reloptions))
   17123             :             {
   17124          16 :                 if (addcomma)
   17125          16 :                     appendPQExpBufferStr(q, ", ");
   17126          16 :                 appendReloptionsArrayAH(q, tbinfo->toast_reloptions, "toast.",
   17127             :                                         fout);
   17128             :             }
   17129         424 :             appendPQExpBufferChar(q, ')');
   17130             :         }
   17131             : 
   17132             :         /* Dump generic options if any */
   17133       15756 :         if (ftoptions && ftoptions[0])
   17134          72 :             appendPQExpBuffer(q, "\nOPTIONS (\n    %s\n)", ftoptions);
   17135             : 
   17136             :         /*
   17137             :          * For materialized views, create the AS clause just like a view. At
   17138             :          * this point, we always mark the view as not populated.
   17139             :          */
   17140       15756 :         if (tbinfo->relkind == RELKIND_MATVIEW)
   17141             :         {
   17142             :             PQExpBuffer result;
   17143             : 
   17144         848 :             result = createViewAsClause(fout, tbinfo);
   17145         848 :             appendPQExpBuffer(q, " AS\n%s\n  WITH NO DATA;\n",
   17146             :                               result->data);
   17147         848 :             destroyPQExpBuffer(result);
   17148             :         }
   17149             :         else
   17150       14908 :             appendPQExpBufferStr(q, ";\n");
   17151             : 
   17152             :         /* Materialized views can depend on extensions */
   17153       15756 :         if (tbinfo->relkind == RELKIND_MATVIEW)
   17154         848 :             append_depends_on_extension(fout, q, &tbinfo->dobj,
   17155             :                                         "pg_catalog.pg_class",
   17156             :                                         "MATERIALIZED VIEW",
   17157             :                                         qualrelname);
   17158             : 
   17159             :         /*
   17160             :          * in binary upgrade mode, update the catalog with any missing values
   17161             :          * that might be present.
   17162             :          */
   17163       15756 :         if (dopt->binary_upgrade)
   17164             :         {
   17165        7768 :             for (j = 0; j < tbinfo->numatts; j++)
   17166             :             {
   17167        6200 :                 if (tbinfo->attmissingval[j][0] != '\0')
   17168             :                 {
   17169           4 :                     appendPQExpBufferStr(q, "\n-- set missing value.\n");
   17170           4 :                     appendPQExpBufferStr(q,
   17171             :                                          "SELECT pg_catalog.binary_upgrade_set_missing_value(");
   17172           4 :                     appendStringLiteralAH(q, qualrelname, fout);
   17173           4 :                     appendPQExpBufferStr(q, "::pg_catalog.regclass,");
   17174           4 :                     appendStringLiteralAH(q, tbinfo->attnames[j], fout);
   17175           4 :                     appendPQExpBufferChar(q, ',');
   17176           4 :                     appendStringLiteralAH(q, tbinfo->attmissingval[j], fout);
   17177           4 :                     appendPQExpBufferStr(q, ");\n\n");
   17178             :                 }
   17179             :             }
   17180             :         }
   17181             : 
   17182             :         /*
   17183             :          * To create binary-compatible heap files, we have to ensure the same
   17184             :          * physical column order, including dropped columns, as in the
   17185             :          * original.  Therefore, we create dropped columns above and drop them
   17186             :          * here, also updating their attlen/attalign values so that the
   17187             :          * dropped column can be skipped properly.  (We do not bother with
   17188             :          * restoring the original attbyval setting.)  Also, inheritance
   17189             :          * relationships are set up by doing ALTER TABLE INHERIT rather than
   17190             :          * using an INHERITS clause --- the latter would possibly mess up the
   17191             :          * column order.  That also means we have to take care about setting
   17192             :          * attislocal correctly, plus fix up any inherited CHECK constraints.
   17193             :          * Analogously, we set up typed tables using ALTER TABLE / OF here.
   17194             :          *
   17195             :          * We process foreign and partitioned tables here, even though they
   17196             :          * lack heap storage, because they can participate in inheritance
   17197             :          * relationships and we want this stuff to be consistent across the
   17198             :          * inheritance tree.  We can exclude indexes, toast tables, sequences
   17199             :          * and matviews, even though they have storage, because we don't
   17200             :          * support altering or dropping columns in them, nor can they be part
   17201             :          * of inheritance trees.
   17202             :          */
   17203       15756 :         if (dopt->binary_upgrade &&
   17204        1568 :             (tbinfo->relkind == RELKIND_RELATION ||
   17205         218 :              tbinfo->relkind == RELKIND_FOREIGN_TABLE ||
   17206         216 :              tbinfo->relkind == RELKIND_PARTITIONED_TABLE))
   17207             :         {
   17208             :             bool        firstitem;
   17209             :             bool        firstitem_extra;
   17210             : 
   17211             :             /*
   17212             :              * Drop any dropped columns.  Merge the pg_attribute manipulations
   17213             :              * into a single SQL command, so that we don't cause repeated
   17214             :              * relcache flushes on the target table.  Otherwise we risk O(N^2)
   17215             :              * relcache bloat while dropping N columns.
   17216             :              */
   17217        1532 :             resetPQExpBuffer(extra);
   17218        1532 :             firstitem = true;
   17219        7688 :             for (j = 0; j < tbinfo->numatts; j++)
   17220             :             {
   17221        6156 :                 if (tbinfo->attisdropped[j])
   17222             :                 {
   17223         168 :                     if (firstitem)
   17224             :                     {
   17225          76 :                         appendPQExpBufferStr(q, "\n-- For binary upgrade, recreate dropped columns.\n"
   17226             :                                              "UPDATE pg_catalog.pg_attribute\n"
   17227             :                                              "SET attlen = v.dlen, "
   17228             :                                              "attalign = v.dalign, "
   17229             :                                              "attbyval = false\n"
   17230             :                                              "FROM (VALUES ");
   17231          76 :                         firstitem = false;
   17232             :                     }
   17233             :                     else
   17234          92 :                         appendPQExpBufferStr(q, ",\n             ");
   17235         168 :                     appendPQExpBufferChar(q, '(');
   17236         168 :                     appendStringLiteralAH(q, tbinfo->attnames[j], fout);
   17237         168 :                     appendPQExpBuffer(q, ", %d, '%c')",
   17238         168 :                                       tbinfo->attlen[j],
   17239         168 :                                       tbinfo->attalign[j]);
   17240             :                     /* The ALTER ... DROP COLUMN commands must come after */
   17241         168 :                     appendPQExpBuffer(extra, "ALTER %sTABLE ONLY %s ",
   17242             :                                       foreign, qualrelname);
   17243         168 :                     appendPQExpBuffer(extra, "DROP COLUMN %s;\n",
   17244         168 :                                       fmtId(tbinfo->attnames[j]));
   17245             :                 }
   17246             :             }
   17247        1532 :             if (!firstitem)
   17248             :             {
   17249          76 :                 appendPQExpBufferStr(q, ") v(dname, dlen, dalign)\n"
   17250             :                                      "WHERE attrelid = ");
   17251          76 :                 appendStringLiteralAH(q, qualrelname, fout);
   17252          76 :                 appendPQExpBufferStr(q, "::pg_catalog.regclass\n"
   17253             :                                      "  AND attname = v.dname;\n");
   17254             :                 /* Now we can issue the actual DROP COLUMN commands */
   17255          76 :                 appendBinaryPQExpBuffer(q, extra->data, extra->len);
   17256             :             }
   17257             : 
   17258             :             /*
   17259             :              * Fix up inherited columns.  As above, do the pg_attribute
   17260             :              * manipulations in a single SQL command.
   17261             :              */
   17262        1532 :             firstitem = true;
   17263        7688 :             for (j = 0; j < tbinfo->numatts; j++)
   17264             :             {
   17265        6156 :                 if (!tbinfo->attisdropped[j] &&
   17266        5988 :                     !tbinfo->attislocal[j])
   17267             :                 {
   17268        1192 :                     if (firstitem)
   17269             :                     {
   17270         518 :                         appendPQExpBufferStr(q, "\n-- For binary upgrade, recreate inherited columns.\n");
   17271         518 :                         appendPQExpBufferStr(q, "UPDATE pg_catalog.pg_attribute\n"
   17272             :                                              "SET attislocal = false\n"
   17273             :                                              "WHERE attrelid = ");
   17274         518 :                         appendStringLiteralAH(q, qualrelname, fout);
   17275         518 :                         appendPQExpBufferStr(q, "::pg_catalog.regclass\n"
   17276             :                                              "  AND attname IN (");
   17277         518 :                         firstitem = false;
   17278             :                     }
   17279             :                     else
   17280         674 :                         appendPQExpBufferStr(q, ", ");
   17281        1192 :                     appendStringLiteralAH(q, tbinfo->attnames[j], fout);
   17282             :                 }
   17283             :             }
   17284        1532 :             if (!firstitem)
   17285         518 :                 appendPQExpBufferStr(q, ");\n");
   17286             : 
   17287             :             /*
   17288             :              * Fix up not-null constraints that come from inheritance.  As
   17289             :              * above, do the pg_constraint manipulations in a single SQL
   17290             :              * command.  (Actually, two in special cases, if we're doing an
   17291             :              * upgrade from < 18).
   17292             :              */
   17293        1532 :             firstitem = true;
   17294        1532 :             firstitem_extra = true;
   17295        1532 :             resetPQExpBuffer(extra);
   17296        7688 :             for (j = 0; j < tbinfo->numatts; j++)
   17297             :             {
   17298             :                 /*
   17299             :                  * If a not-null constraint comes from inheritance, reset
   17300             :                  * conislocal.  The inhcount is fixed by ALTER TABLE INHERIT,
   17301             :                  * below.  Special hack: in versions < 18, columns with no
   17302             :                  * local definition need their constraint to be matched by
   17303             :                  * column number in conkeys instead of by constraint name,
   17304             :                  * because the latter is not available.  (We distinguish the
   17305             :                  * case because the constraint name is the empty string.)
   17306             :                  */
   17307        6156 :                 if (tbinfo->notnull_constrs[j] != NULL &&
   17308         560 :                     !tbinfo->notnull_islocal[j])
   17309             :                 {
   17310         170 :                     if (tbinfo->notnull_constrs[j][0] != '\0')
   17311             :                     {
   17312         144 :                         if (firstitem)
   17313             :                         {
   17314         124 :                             appendPQExpBufferStr(q, "UPDATE pg_catalog.pg_constraint\n"
   17315             :                                                  "SET conislocal = false\n"
   17316             :                                                  "WHERE contype = 'n' AND conrelid = ");
   17317         124 :                             appendStringLiteralAH(q, qualrelname, fout);
   17318         124 :                             appendPQExpBufferStr(q, "::pg_catalog.regclass AND\n"
   17319             :                                                  "conname IN (");
   17320         124 :                             firstitem = false;
   17321             :                         }
   17322             :                         else
   17323          20 :                             appendPQExpBufferStr(q, ", ");
   17324         144 :                         appendStringLiteralAH(q, tbinfo->notnull_constrs[j], fout);
   17325             :                     }
   17326             :                     else
   17327             :                     {
   17328          26 :                         if (firstitem_extra)
   17329             :                         {
   17330          26 :                             appendPQExpBufferStr(extra, "UPDATE pg_catalog.pg_constraint\n"
   17331             :                                                  "SET conislocal = false\n"
   17332             :                                                  "WHERE contype = 'n' AND conrelid = ");
   17333          26 :                             appendStringLiteralAH(extra, qualrelname, fout);
   17334          26 :                             appendPQExpBufferStr(extra, "::pg_catalog.regclass AND\n"
   17335             :                                                  "conkey IN (");
   17336          26 :                             firstitem_extra = false;
   17337             :                         }
   17338             :                         else
   17339           0 :                             appendPQExpBufferStr(extra, ", ");
   17340          26 :                         appendPQExpBuffer(extra, "'{%d}'", j + 1);
   17341             :                     }
   17342             :                 }
   17343             :             }
   17344        1532 :             if (!firstitem)
   17345         124 :                 appendPQExpBufferStr(q, ");\n");
   17346        1532 :             if (!firstitem_extra)
   17347          26 :                 appendPQExpBufferStr(extra, ");\n");
   17348             : 
   17349        1532 :             if (extra->len > 0)
   17350          26 :                 appendBinaryPQExpBuffer(q, extra->data, extra->len);
   17351             : 
   17352             :             /*
   17353             :              * Add inherited CHECK constraints, if any.
   17354             :              *
   17355             :              * For partitions, they were already dumped, and conislocal
   17356             :              * doesn't need fixing.
   17357             :              *
   17358             :              * As above, issue only one direct manipulation of pg_constraint.
   17359             :              * Although it is tempting to merge the ALTER ADD CONSTRAINT
   17360             :              * commands into one as well, refrain for now due to concern about
   17361             :              * possible backend memory bloat if there are many such
   17362             :              * constraints.
   17363             :              */
   17364        1532 :             resetPQExpBuffer(extra);
   17365        1532 :             firstitem = true;
   17366        1660 :             for (k = 0; k < tbinfo->ncheck; k++)
   17367             :             {
   17368         128 :                 ConstraintInfo *constr = &(tbinfo->checkexprs[k]);
   17369             : 
   17370         128 :                 if (constr->separate || constr->conislocal || tbinfo->ispartition)
   17371         124 :                     continue;
   17372             : 
   17373           4 :                 if (firstitem)
   17374           4 :                     appendPQExpBufferStr(q, "\n-- For binary upgrade, set up inherited constraints.\n");
   17375           4 :                 appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s ADD CONSTRAINT %s %s;\n",
   17376             :                                   foreign, qualrelname,
   17377           4 :                                   fmtId(constr->dobj.name),
   17378             :                                   constr->condef);
   17379             :                 /* Update pg_constraint after all the ALTER TABLEs */
   17380           4 :                 if (firstitem)
   17381             :                 {
   17382           4 :                     appendPQExpBufferStr(extra, "UPDATE pg_catalog.pg_constraint\n"
   17383             :                                          "SET conislocal = false\n"
   17384             :                                          "WHERE contype = 'c' AND conrelid = ");
   17385           4 :                     appendStringLiteralAH(extra, qualrelname, fout);
   17386           4 :                     appendPQExpBufferStr(extra, "::pg_catalog.regclass\n");
   17387           4 :                     appendPQExpBufferStr(extra, "  AND conname IN (");
   17388           4 :                     firstitem = false;
   17389             :                 }
   17390             :                 else
   17391           0 :                     appendPQExpBufferStr(extra, ", ");
   17392           4 :                 appendStringLiteralAH(extra, constr->dobj.name, fout);
   17393             :             }
   17394        1532 :             if (!firstitem)
   17395             :             {
   17396           4 :                 appendPQExpBufferStr(extra, ");\n");
   17397           4 :                 appendBinaryPQExpBuffer(q, extra->data, extra->len);
   17398             :             }
   17399             : 
   17400        1532 :             if (numParents > 0 && !tbinfo->ispartition)
   17401             :             {
   17402         112 :                 appendPQExpBufferStr(q, "\n-- For binary upgrade, set up inheritance this way.\n");
   17403         240 :                 for (k = 0; k < numParents; k++)
   17404             :                 {
   17405         128 :                     TableInfo  *parentRel = parents[k];
   17406             : 
   17407         128 :                     appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s INHERIT %s;\n", foreign,
   17408             :                                       qualrelname,
   17409         128 :                                       fmtQualifiedDumpable(parentRel));
   17410             :                 }
   17411             :             }
   17412             : 
   17413        1532 :             if (OidIsValid(tbinfo->reloftype))
   17414             :             {
   17415          12 :                 appendPQExpBufferStr(q, "\n-- For binary upgrade, set up typed tables this way.\n");
   17416          12 :                 appendPQExpBuffer(q, "ALTER TABLE ONLY %s OF %s;\n",
   17417             :                                   qualrelname,
   17418             :                                   getFormattedTypeName(fout, tbinfo->reloftype,
   17419             :                                                        zeroIsError));
   17420             :             }
   17421             :         }
   17422             : 
   17423             :         /*
   17424             :          * In binary_upgrade mode, arrange to restore the old relfrozenxid and
   17425             :          * relminmxid of all vacuumable relations.  (While vacuum.c processes
   17426             :          * TOAST tables semi-independently, here we see them only as children
   17427             :          * of other relations; so this "if" lacks RELKIND_TOASTVALUE, and the
   17428             :          * child toast table is handled below.)
   17429             :          */
   17430       15756 :         if (dopt->binary_upgrade &&
   17431        1568 :             (tbinfo->relkind == RELKIND_RELATION ||
   17432         218 :              tbinfo->relkind == RELKIND_MATVIEW))
   17433             :         {
   17434        1386 :             appendPQExpBufferStr(q, "\n-- For binary upgrade, set heap's relfrozenxid and relminmxid\n");
   17435        1386 :             appendPQExpBuffer(q, "UPDATE pg_catalog.pg_class\n"
   17436             :                               "SET relfrozenxid = '%u', relminmxid = '%u'\n"
   17437             :                               "WHERE oid = ",
   17438             :                               tbinfo->frozenxid, tbinfo->minmxid);
   17439        1386 :             appendStringLiteralAH(q, qualrelname, fout);
   17440        1386 :             appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
   17441             : 
   17442        1386 :             if (tbinfo->toast_oid)
   17443             :             {
   17444             :                 /*
   17445             :                  * The toast table will have the same OID at restore, so we
   17446             :                  * can safely target it by OID.
   17447             :                  */
   17448         552 :                 appendPQExpBufferStr(q, "\n-- For binary upgrade, set toast's relfrozenxid and relminmxid\n");
   17449         552 :                 appendPQExpBuffer(q, "UPDATE pg_catalog.pg_class\n"
   17450             :                                   "SET relfrozenxid = '%u', relminmxid = '%u'\n"
   17451             :                                   "WHERE oid = '%u';\n",
   17452             :                                   tbinfo->toast_frozenxid,
   17453             :                                   tbinfo->toast_minmxid, tbinfo->toast_oid);
   17454             :             }
   17455             :         }
   17456             : 
   17457             :         /*
   17458             :          * In binary_upgrade mode, restore matviews' populated status by
   17459             :          * poking pg_class directly.  This is pretty ugly, but we can't use
   17460             :          * REFRESH MATERIALIZED VIEW since it's possible that some underlying
   17461             :          * matview is not populated even though this matview is; in any case,
   17462             :          * we want to transfer the matview's heap storage, not run REFRESH.
   17463             :          */
   17464       15756 :         if (dopt->binary_upgrade && tbinfo->relkind == RELKIND_MATVIEW &&
   17465          36 :             tbinfo->relispopulated)
   17466             :         {
   17467          32 :             appendPQExpBufferStr(q, "\n-- For binary upgrade, mark materialized view as populated\n");
   17468          32 :             appendPQExpBufferStr(q, "UPDATE pg_catalog.pg_class\n"
   17469             :                                  "SET relispopulated = 't'\n"
   17470             :                                  "WHERE oid = ");
   17471          32 :             appendStringLiteralAH(q, qualrelname, fout);
   17472          32 :             appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
   17473             :         }
   17474             : 
   17475             :         /*
   17476             :          * Dump additional per-column properties that we can't handle in the
   17477             :          * main CREATE TABLE command.
   17478             :          */
   17479       74394 :         for (j = 0; j < tbinfo->numatts; j++)
   17480             :         {
   17481             :             /* None of this applies to dropped columns */
   17482       58638 :             if (tbinfo->attisdropped[j])
   17483        1234 :                 continue;
   17484             : 
   17485             :             /*
   17486             :              * Dump per-column statistics information. We only issue an ALTER
   17487             :              * TABLE statement if the attstattarget entry for this column is
   17488             :              * not the default value.
   17489             :              */
   17490       57404 :             if (tbinfo->attstattarget[j] >= 0)
   17491          72 :                 appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET STATISTICS %d;\n",
   17492             :                                   foreign, qualrelname,
   17493          72 :                                   fmtId(tbinfo->attnames[j]),
   17494          72 :                                   tbinfo->attstattarget[j]);
   17495             : 
   17496             :             /*
   17497             :              * Dump per-column storage information.  The statement is only
   17498             :              * dumped if the storage has been changed from the type's default.
   17499             :              */
   17500       57404 :             if (tbinfo->attstorage[j] != tbinfo->typstorage[j])
   17501             :             {
   17502         192 :                 switch (tbinfo->attstorage[j])
   17503             :                 {
   17504          32 :                     case TYPSTORAGE_PLAIN:
   17505          32 :                         storage = "PLAIN";
   17506          32 :                         break;
   17507          88 :                     case TYPSTORAGE_EXTERNAL:
   17508          88 :                         storage = "EXTERNAL";
   17509          88 :                         break;
   17510           0 :                     case TYPSTORAGE_EXTENDED:
   17511           0 :                         storage = "EXTENDED";
   17512           0 :                         break;
   17513          72 :                     case TYPSTORAGE_MAIN:
   17514          72 :                         storage = "MAIN";
   17515          72 :                         break;
   17516           0 :                     default:
   17517           0 :                         storage = NULL;
   17518             :                 }
   17519             : 
   17520             :                 /*
   17521             :                  * Only dump the statement if it's a storage type we recognize
   17522             :                  */
   17523         192 :                 if (storage != NULL)
   17524         192 :                     appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET STORAGE %s;\n",
   17525             :                                       foreign, qualrelname,
   17526         192 :                                       fmtId(tbinfo->attnames[j]),
   17527             :                                       storage);
   17528             :             }
   17529             : 
   17530             :             /*
   17531             :              * Dump per-column compression, if it's been set.
   17532             :              */
   17533       57404 :             if (!dopt->no_toast_compression)
   17534             :             {
   17535             :                 const char *cmname;
   17536             : 
   17537       57222 :                 switch (tbinfo->attcompression[j])
   17538             :                 {
   17539         150 :                     case 'p':
   17540         150 :                         cmname = "pglz";
   17541         150 :                         break;
   17542         236 :                     case 'l':
   17543         236 :                         cmname = "lz4";
   17544         236 :                         break;
   17545       56836 :                     default:
   17546       56836 :                         cmname = NULL;
   17547       56836 :                         break;
   17548             :                 }
   17549             : 
   17550       57222 :                 if (cmname != NULL)
   17551         386 :                     appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET COMPRESSION %s;\n",
   17552             :                                       foreign, qualrelname,
   17553         386 :                                       fmtId(tbinfo->attnames[j]),
   17554             :                                       cmname);
   17555             :             }
   17556             : 
   17557             :             /*
   17558             :              * Dump per-column attributes.
   17559             :              */
   17560       57404 :             if (tbinfo->attoptions[j][0] != '\0')
   17561          72 :                 appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET (%s);\n",
   17562             :                                   foreign, qualrelname,
   17563          72 :                                   fmtId(tbinfo->attnames[j]),
   17564          72 :                                   tbinfo->attoptions[j]);
   17565             : 
   17566             :             /*
   17567             :              * Dump per-column fdw options.
   17568             :              */
   17569       57404 :             if (tbinfo->relkind == RELKIND_FOREIGN_TABLE &&
   17570          76 :                 tbinfo->attfdwoptions[j][0] != '\0')
   17571          72 :                 appendPQExpBuffer(q,
   17572             :                                   "ALTER FOREIGN TABLE ONLY %s ALTER COLUMN %s OPTIONS (\n"
   17573             :                                   "    %s\n"
   17574             :                                   ");\n",
   17575             :                                   qualrelname,
   17576          72 :                                   fmtId(tbinfo->attnames[j]),
   17577          72 :                                   tbinfo->attfdwoptions[j]);
   17578             :         }                       /* end loop over columns */
   17579             : 
   17580       15756 :         free(partkeydef);
   17581       15756 :         free(ftoptions);
   17582       15756 :         free(srvname);
   17583             :     }
   17584             : 
   17585             :     /*
   17586             :      * dump properties we only have ALTER TABLE syntax for
   17587             :      */
   17588       17108 :     if ((tbinfo->relkind == RELKIND_RELATION ||
   17589        3892 :          tbinfo->relkind == RELKIND_PARTITIONED_TABLE ||
   17590        2276 :          tbinfo->relkind == RELKIND_MATVIEW) &&
   17591       15680 :         tbinfo->relreplident != REPLICA_IDENTITY_DEFAULT)
   17592             :     {
   17593         384 :         if (tbinfo->relreplident == REPLICA_IDENTITY_INDEX)
   17594             :         {
   17595             :             /* nothing to do, will be set when the index is dumped */
   17596             :         }
   17597         384 :         else if (tbinfo->relreplident == REPLICA_IDENTITY_NOTHING)
   17598             :         {
   17599         384 :             appendPQExpBuffer(q, "\nALTER TABLE ONLY %s REPLICA IDENTITY NOTHING;\n",
   17600             :                               qualrelname);
   17601             :         }
   17602           0 :         else if (tbinfo->relreplident == REPLICA_IDENTITY_FULL)
   17603             :         {
   17604           0 :             appendPQExpBuffer(q, "\nALTER TABLE ONLY %s REPLICA IDENTITY FULL;\n",
   17605             :                               qualrelname);
   17606             :         }
   17607             :     }
   17608             : 
   17609       17108 :     if (tbinfo->forcerowsec)
   17610          16 :         appendPQExpBuffer(q, "\nALTER TABLE ONLY %s FORCE ROW LEVEL SECURITY;\n",
   17611             :                           qualrelname);
   17612             : 
   17613       17108 :     if (dopt->binary_upgrade)
   17614        1670 :         binary_upgrade_extension_member(q, &tbinfo->dobj,
   17615             :                                         reltypename, qrelname,
   17616        1670 :                                         tbinfo->dobj.namespace->dobj.name);
   17617             : 
   17618       17108 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   17619             :     {
   17620       17108 :         char       *tablespace = NULL;
   17621       17108 :         char       *tableam = NULL;
   17622             : 
   17623             :         /*
   17624             :          * _selectTablespace() relies on tablespace-enabled objects in the
   17625             :          * default tablespace to have a tablespace of "" (empty string) versus
   17626             :          * non-tablespace-enabled objects to have a tablespace of NULL.
   17627             :          * getTables() sets tbinfo->reltablespace to "" for the default
   17628             :          * tablespace (not NULL).
   17629             :          */
   17630       17108 :         if (RELKIND_HAS_TABLESPACE(tbinfo->relkind))
   17631       15680 :             tablespace = tbinfo->reltablespace;
   17632             : 
   17633       17108 :         if (RELKIND_HAS_TABLE_AM(tbinfo->relkind) ||
   17634        3044 :             tbinfo->relkind == RELKIND_PARTITIONED_TABLE)
   17635       15680 :             tableam = tbinfo->amname;
   17636             : 
   17637       17108 :         ArchiveEntry(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
   17638       17108 :                      ARCHIVE_OPTS(.tag = tbinfo->dobj.name,
   17639             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   17640             :                                   .tablespace = tablespace,
   17641             :                                   .tableam = tableam,
   17642             :                                   .relkind = tbinfo->relkind,
   17643             :                                   .owner = tbinfo->rolname,
   17644             :                                   .description = reltypename,
   17645             :                                   .section = tbinfo->postponed_def ?
   17646             :                                   SECTION_POST_DATA : SECTION_PRE_DATA,
   17647             :                                   .createStmt = q->data,
   17648             :                                   .dropStmt = delq->data));
   17649             :     }
   17650             : 
   17651             :     /* Dump Table Comments */
   17652       17108 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   17653         176 :         dumpTableComment(fout, tbinfo, reltypename);
   17654             : 
   17655             :     /* Dump Table Security Labels */
   17656       17108 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   17657           0 :         dumpTableSecLabel(fout, tbinfo, reltypename);
   17658             : 
   17659             :     /* Dump comments on inlined table constraints */
   17660       18660 :     for (j = 0; j < tbinfo->ncheck; j++)
   17661             :     {
   17662        1552 :         ConstraintInfo *constr = &(tbinfo->checkexprs[j]);
   17663             : 
   17664        1552 :         if (constr->separate || !constr->conislocal)
   17665         624 :             continue;
   17666             : 
   17667         928 :         if (constr->dobj.dump & DUMP_COMPONENT_COMMENT)
   17668          88 :             dumpTableConstraintComment(fout, constr);
   17669             :     }
   17670             : 
   17671       17108 :     destroyPQExpBuffer(q);
   17672       17108 :     destroyPQExpBuffer(delq);
   17673       17108 :     destroyPQExpBuffer(extra);
   17674       17108 :     free(qrelname);
   17675       17108 :     free(qualrelname);
   17676       17108 : }
   17677             : 
   17678             : /*
   17679             :  * dumpTableAttach
   17680             :  *    write to fout the commands to attach a child partition
   17681             :  *
   17682             :  * Child partitions are always made by creating them separately
   17683             :  * and then using ATTACH PARTITION, rather than using
   17684             :  * CREATE TABLE ... PARTITION OF.  This is important for preserving
   17685             :  * any possible discrepancy in column layout, to allow assigning the
   17686             :  * correct tablespace if different, and so that it's possible to restore
   17687             :  * a partition without restoring its parent.  (You'll get an error from
   17688             :  * the ATTACH PARTITION command, but that can be ignored, or skipped
   17689             :  * using "pg_restore -L" if you prefer.)  The last point motivates
   17690             :  * treating ATTACH PARTITION as a completely separate ArchiveEntry
   17691             :  * rather than emitting it within the child partition's ArchiveEntry.
   17692             :  */
   17693             : static void
   17694        3900 : dumpTableAttach(Archive *fout, const TableAttachInfo *attachinfo)
   17695             : {
   17696        3900 :     DumpOptions *dopt = fout->dopt;
   17697             :     PQExpBuffer q;
   17698             :     PGresult   *res;
   17699             :     char       *partbound;
   17700             : 
   17701             :     /* Do nothing if not dumping schema */
   17702        3900 :     if (!dopt->dumpSchema)
   17703          84 :         return;
   17704             : 
   17705        3816 :     q = createPQExpBuffer();
   17706             : 
   17707        3816 :     if (!fout->is_prepared[PREPQUERY_DUMPTABLEATTACH])
   17708             :     {
   17709             :         /* Set up query for partbound details */
   17710         100 :         appendPQExpBufferStr(q,
   17711             :                              "PREPARE dumpTableAttach(pg_catalog.oid) AS\n");
   17712             : 
   17713         100 :         appendPQExpBufferStr(q,
   17714             :                              "SELECT pg_get_expr(c.relpartbound, c.oid) "
   17715             :                              "FROM pg_class c "
   17716             :                              "WHERE c.oid = $1");
   17717             : 
   17718         100 :         ExecuteSqlStatement(fout, q->data);
   17719             : 
   17720         100 :         fout->is_prepared[PREPQUERY_DUMPTABLEATTACH] = true;
   17721             :     }
   17722             : 
   17723        3816 :     printfPQExpBuffer(q,
   17724             :                       "EXECUTE dumpTableAttach('%u')",
   17725        3816 :                       attachinfo->partitionTbl->dobj.catId.oid);
   17726             : 
   17727        3816 :     res = ExecuteSqlQueryForSingleRow(fout, q->data);
   17728        3816 :     partbound = PQgetvalue(res, 0, 0);
   17729             : 
   17730             :     /* Perform ALTER TABLE on the parent */
   17731        3816 :     printfPQExpBuffer(q,
   17732             :                       "ALTER TABLE ONLY %s ",
   17733        3816 :                       fmtQualifiedDumpable(attachinfo->parentTbl));
   17734        3816 :     appendPQExpBuffer(q,
   17735             :                       "ATTACH PARTITION %s %s;\n",
   17736        3816 :                       fmtQualifiedDumpable(attachinfo->partitionTbl),
   17737             :                       partbound);
   17738             : 
   17739             :     /*
   17740             :      * There is no point in creating a drop query as the drop is done by table
   17741             :      * drop.  (If you think to change this, see also _printTocEntry().)
   17742             :      * Although this object doesn't really have ownership as such, set the
   17743             :      * owner field anyway to ensure that the command is run by the correct
   17744             :      * role at restore time.
   17745             :      */
   17746        3816 :     ArchiveEntry(fout, attachinfo->dobj.catId, attachinfo->dobj.dumpId,
   17747        3816 :                  ARCHIVE_OPTS(.tag = attachinfo->dobj.name,
   17748             :                               .namespace = attachinfo->dobj.namespace->dobj.name,
   17749             :                               .owner = attachinfo->partitionTbl->rolname,
   17750             :                               .description = "TABLE ATTACH",
   17751             :                               .section = SECTION_PRE_DATA,
   17752             :                               .createStmt = q->data));
   17753             : 
   17754        3816 :     PQclear(res);
   17755        3816 :     destroyPQExpBuffer(q);
   17756             : }
   17757             : 
   17758             : /*
   17759             :  * dumpAttrDef --- dump an attribute's default-value declaration
   17760             :  */
   17761             : static void
   17762        2900 : dumpAttrDef(Archive *fout, const AttrDefInfo *adinfo)
   17763             : {
   17764        2900 :     DumpOptions *dopt = fout->dopt;
   17765        2900 :     TableInfo  *tbinfo = adinfo->adtable;
   17766        2900 :     int         adnum = adinfo->adnum;
   17767             :     PQExpBuffer q;
   17768             :     PQExpBuffer delq;
   17769             :     char       *qualrelname;
   17770             :     char       *tag;
   17771             :     char       *foreign;
   17772             : 
   17773             :     /* Do nothing if not dumping schema */
   17774        2900 :     if (!dopt->dumpSchema)
   17775           0 :         return;
   17776             : 
   17777             :     /* Skip if not "separate"; it was dumped in the table's definition */
   17778        2900 :     if (!adinfo->separate)
   17779        2460 :         return;
   17780             : 
   17781         440 :     q = createPQExpBuffer();
   17782         440 :     delq = createPQExpBuffer();
   17783             : 
   17784         440 :     qualrelname = pg_strdup(fmtQualifiedDumpable(tbinfo));
   17785             : 
   17786         440 :     foreign = tbinfo->relkind == RELKIND_FOREIGN_TABLE ? "FOREIGN " : "";
   17787             : 
   17788         440 :     appendPQExpBuffer(q,
   17789             :                       "ALTER %sTABLE ONLY %s ALTER COLUMN %s SET DEFAULT %s;\n",
   17790         440 :                       foreign, qualrelname, fmtId(tbinfo->attnames[adnum - 1]),
   17791             :                       adinfo->adef_expr);
   17792             : 
   17793         440 :     appendPQExpBuffer(delq, "ALTER %sTABLE %s ALTER COLUMN %s DROP DEFAULT;\n",
   17794             :                       foreign, qualrelname,
   17795         440 :                       fmtId(tbinfo->attnames[adnum - 1]));
   17796             : 
   17797         440 :     tag = psprintf("%s %s", tbinfo->dobj.name, tbinfo->attnames[adnum - 1]);
   17798             : 
   17799         440 :     if (adinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   17800         440 :         ArchiveEntry(fout, adinfo->dobj.catId, adinfo->dobj.dumpId,
   17801         440 :                      ARCHIVE_OPTS(.tag = tag,
   17802             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   17803             :                                   .owner = tbinfo->rolname,
   17804             :                                   .description = "DEFAULT",
   17805             :                                   .section = SECTION_PRE_DATA,
   17806             :                                   .createStmt = q->data,
   17807             :                                   .dropStmt = delq->data));
   17808             : 
   17809         440 :     free(tag);
   17810         440 :     destroyPQExpBuffer(q);
   17811         440 :     destroyPQExpBuffer(delq);
   17812         440 :     free(qualrelname);
   17813             : }
   17814             : 
   17815             : /*
   17816             :  * getAttrName: extract the correct name for an attribute
   17817             :  *
   17818             :  * The array tblInfo->attnames[] only provides names of user attributes;
   17819             :  * if a system attribute number is supplied, we have to fake it.
   17820             :  * We also do a little bit of bounds checking for safety's sake.
   17821             :  */
   17822             : static const char *
   17823        5188 : getAttrName(int attrnum, const TableInfo *tblInfo)
   17824             : {
   17825        5188 :     if (attrnum > 0 && attrnum <= tblInfo->numatts)
   17826        5188 :         return tblInfo->attnames[attrnum - 1];
   17827           0 :     switch (attrnum)
   17828             :     {
   17829           0 :         case SelfItemPointerAttributeNumber:
   17830           0 :             return "ctid";
   17831           0 :         case MinTransactionIdAttributeNumber:
   17832           0 :             return "xmin";
   17833           0 :         case MinCommandIdAttributeNumber:
   17834           0 :             return "cmin";
   17835           0 :         case MaxTransactionIdAttributeNumber:
   17836           0 :             return "xmax";
   17837           0 :         case MaxCommandIdAttributeNumber:
   17838           0 :             return "cmax";
   17839           0 :         case TableOidAttributeNumber:
   17840           0 :             return "tableoid";
   17841             :     }
   17842           0 :     pg_fatal("invalid column number %d for table \"%s\"",
   17843             :              attrnum, tblInfo->dobj.name);
   17844             :     return NULL;                /* keep compiler quiet */
   17845             : }
   17846             : 
   17847             : /*
   17848             :  * dumpIndex
   17849             :  *    write out to fout a user-defined index
   17850             :  */
   17851             : static void
   17852        6938 : dumpIndex(Archive *fout, const IndxInfo *indxinfo)
   17853             : {
   17854        6938 :     DumpOptions *dopt = fout->dopt;
   17855        6938 :     TableInfo  *tbinfo = indxinfo->indextable;
   17856        6938 :     bool        is_constraint = (indxinfo->indexconstraint != 0);
   17857             :     PQExpBuffer q;
   17858             :     PQExpBuffer delq;
   17859             :     char       *qindxname;
   17860             :     char       *qqindxname;
   17861             : 
   17862             :     /* Do nothing if not dumping schema */
   17863        6938 :     if (!dopt->dumpSchema)
   17864         234 :         return;
   17865             : 
   17866        6704 :     q = createPQExpBuffer();
   17867        6704 :     delq = createPQExpBuffer();
   17868             : 
   17869        6704 :     qindxname = pg_strdup(fmtId(indxinfo->dobj.name));
   17870        6704 :     qqindxname = pg_strdup(fmtQualifiedDumpable(indxinfo));
   17871             : 
   17872             :     /*
   17873             :      * If there's an associated constraint, don't dump the index per se, but
   17874             :      * do dump any comment for it.  (This is safe because dependency ordering
   17875             :      * will have ensured the constraint is emitted first.)  Note that the
   17876             :      * emitted comment has to be shown as depending on the constraint, not the
   17877             :      * index, in such cases.
   17878             :      */
   17879        6704 :     if (!is_constraint)
   17880             :     {
   17881        2998 :         char       *indstatcols = indxinfo->indstatcols;
   17882        2998 :         char       *indstatvals = indxinfo->indstatvals;
   17883        2998 :         char      **indstatcolsarray = NULL;
   17884        2998 :         char      **indstatvalsarray = NULL;
   17885        2998 :         int         nstatcols = 0;
   17886        2998 :         int         nstatvals = 0;
   17887             : 
   17888        2998 :         if (dopt->binary_upgrade)
   17889         310 :             binary_upgrade_set_pg_class_oids(fout, q,
   17890             :                                              indxinfo->dobj.catId.oid);
   17891             : 
   17892             :         /* Plain secondary index */
   17893        2998 :         appendPQExpBuffer(q, "%s;\n", indxinfo->indexdef);
   17894             : 
   17895             :         /*
   17896             :          * Append ALTER TABLE commands as needed to set properties that we
   17897             :          * only have ALTER TABLE syntax for.  Keep this in sync with the
   17898             :          * similar code in dumpConstraint!
   17899             :          */
   17900             : 
   17901             :         /* If the index is clustered, we need to record that. */
   17902        2998 :         if (indxinfo->indisclustered)
   17903             :         {
   17904           0 :             appendPQExpBuffer(q, "\nALTER TABLE %s CLUSTER",
   17905           0 :                               fmtQualifiedDumpable(tbinfo));
   17906             :             /* index name is not qualified in this syntax */
   17907           0 :             appendPQExpBuffer(q, " ON %s;\n",
   17908             :                               qindxname);
   17909             :         }
   17910             : 
   17911             :         /*
   17912             :          * If the index has any statistics on some of its columns, generate
   17913             :          * the associated ALTER INDEX queries.
   17914             :          */
   17915        2998 :         if (strlen(indstatcols) != 0 || strlen(indstatvals) != 0)
   17916             :         {
   17917             :             int         j;
   17918             : 
   17919          72 :             if (!parsePGArray(indstatcols, &indstatcolsarray, &nstatcols))
   17920           0 :                 pg_fatal("could not parse index statistic columns");
   17921          72 :             if (!parsePGArray(indstatvals, &indstatvalsarray, &nstatvals))
   17922           0 :                 pg_fatal("could not parse index statistic values");
   17923          72 :             if (nstatcols != nstatvals)
   17924           0 :                 pg_fatal("mismatched number of columns and values for index statistics");
   17925             : 
   17926         216 :             for (j = 0; j < nstatcols; j++)
   17927             :             {
   17928         144 :                 appendPQExpBuffer(q, "ALTER INDEX %s ", qqindxname);
   17929             : 
   17930             :                 /*
   17931             :                  * Note that this is a column number, so no quotes should be
   17932             :                  * used.
   17933             :                  */
   17934         144 :                 appendPQExpBuffer(q, "ALTER COLUMN %s ",
   17935         144 :                                   indstatcolsarray[j]);
   17936         144 :                 appendPQExpBuffer(q, "SET STATISTICS %s;\n",
   17937         144 :                                   indstatvalsarray[j]);
   17938             :             }
   17939             :         }
   17940             : 
   17941             :         /* Indexes can depend on extensions */
   17942        2998 :         append_depends_on_extension(fout, q, &indxinfo->dobj,
   17943             :                                     "pg_catalog.pg_class",
   17944             :                                     "INDEX", qqindxname);
   17945             : 
   17946             :         /* If the index defines identity, we need to record that. */
   17947        2998 :         if (indxinfo->indisreplident)
   17948             :         {
   17949           0 :             appendPQExpBuffer(q, "\nALTER TABLE ONLY %s REPLICA IDENTITY USING",
   17950           0 :                               fmtQualifiedDumpable(tbinfo));
   17951             :             /* index name is not qualified in this syntax */
   17952           0 :             appendPQExpBuffer(q, " INDEX %s;\n",
   17953             :                               qindxname);
   17954             :         }
   17955             : 
   17956             :         /*
   17957             :          * If this index is a member of a partitioned index, the backend will
   17958             :          * not allow us to drop it separately, so don't try.  It will go away
   17959             :          * automatically when we drop either the index's table or the
   17960             :          * partitioned index.  (If, in a selective restore with --clean, we
   17961             :          * drop neither of those, then this index will not be dropped either.
   17962             :          * But that's fine, and even if you think it's not, the backend won't
   17963             :          * let us do differently.)
   17964             :          */
   17965        2998 :         if (indxinfo->parentidx == 0)
   17966        2542 :             appendPQExpBuffer(delq, "DROP INDEX %s;\n", qqindxname);
   17967             : 
   17968        2998 :         if (indxinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   17969        2998 :             ArchiveEntry(fout, indxinfo->dobj.catId, indxinfo->dobj.dumpId,
   17970        2998 :                          ARCHIVE_OPTS(.tag = indxinfo->dobj.name,
   17971             :                                       .namespace = tbinfo->dobj.namespace->dobj.name,
   17972             :                                       .tablespace = indxinfo->tablespace,
   17973             :                                       .owner = tbinfo->rolname,
   17974             :                                       .description = "INDEX",
   17975             :                                       .section = SECTION_POST_DATA,
   17976             :                                       .createStmt = q->data,
   17977             :                                       .dropStmt = delq->data));
   17978             : 
   17979        2998 :         free(indstatcolsarray);
   17980        2998 :         free(indstatvalsarray);
   17981             :     }
   17982             : 
   17983             :     /* Dump Index Comments */
   17984        6704 :     if (indxinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   17985          48 :         dumpComment(fout, "INDEX", qindxname,
   17986          48 :                     tbinfo->dobj.namespace->dobj.name,
   17987             :                     tbinfo->rolname,
   17988             :                     indxinfo->dobj.catId, 0,
   17989             :                     is_constraint ? indxinfo->indexconstraint :
   17990             :                     indxinfo->dobj.dumpId);
   17991             : 
   17992        6704 :     destroyPQExpBuffer(q);
   17993        6704 :     destroyPQExpBuffer(delq);
   17994        6704 :     free(qindxname);
   17995        6704 :     free(qqindxname);
   17996             : }
   17997             : 
   17998             : /*
   17999             :  * dumpIndexAttach
   18000             :  *    write out to fout a partitioned-index attachment clause
   18001             :  */
   18002             : static void
   18003        1480 : dumpIndexAttach(Archive *fout, const IndexAttachInfo *attachinfo)
   18004             : {
   18005             :     /* Do nothing if not dumping schema */
   18006        1480 :     if (!fout->dopt->dumpSchema)
   18007          96 :         return;
   18008             : 
   18009        1384 :     if (attachinfo->partitionIdx->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18010             :     {
   18011        1384 :         PQExpBuffer q = createPQExpBuffer();
   18012             : 
   18013        1384 :         appendPQExpBuffer(q, "ALTER INDEX %s ",
   18014        1384 :                           fmtQualifiedDumpable(attachinfo->parentIdx));
   18015        1384 :         appendPQExpBuffer(q, "ATTACH PARTITION %s;\n",
   18016        1384 :                           fmtQualifiedDumpable(attachinfo->partitionIdx));
   18017             : 
   18018             :         /*
   18019             :          * There is no need for a dropStmt since the drop is done implicitly
   18020             :          * when we drop either the index's table or the partitioned index.
   18021             :          * Moreover, since there's no ALTER INDEX DETACH PARTITION command,
   18022             :          * there's no way to do it anyway.  (If you think to change this,
   18023             :          * consider also what to do with --if-exists.)
   18024             :          *
   18025             :          * Although this object doesn't really have ownership as such, set the
   18026             :          * owner field anyway to ensure that the command is run by the correct
   18027             :          * role at restore time.
   18028             :          */
   18029        1384 :         ArchiveEntry(fout, attachinfo->dobj.catId, attachinfo->dobj.dumpId,
   18030        1384 :                      ARCHIVE_OPTS(.tag = attachinfo->dobj.name,
   18031             :                                   .namespace = attachinfo->dobj.namespace->dobj.name,
   18032             :                                   .owner = attachinfo->parentIdx->indextable->rolname,
   18033             :                                   .description = "INDEX ATTACH",
   18034             :                                   .section = SECTION_POST_DATA,
   18035             :                                   .createStmt = q->data));
   18036             : 
   18037        1384 :         destroyPQExpBuffer(q);
   18038             :     }
   18039             : }
   18040             : 
   18041             : /*
   18042             :  * dumpStatisticsExt
   18043             :  *    write out to fout an extended statistics object
   18044             :  */
   18045             : static void
   18046         314 : dumpStatisticsExt(Archive *fout, const StatsExtInfo *statsextinfo)
   18047             : {
   18048         314 :     DumpOptions *dopt = fout->dopt;
   18049             :     PQExpBuffer q;
   18050             :     PQExpBuffer delq;
   18051             :     PQExpBuffer query;
   18052             :     char       *qstatsextname;
   18053             :     PGresult   *res;
   18054             :     char       *stxdef;
   18055             : 
   18056             :     /* Do nothing if not dumping schema */
   18057         314 :     if (!dopt->dumpSchema)
   18058          36 :         return;
   18059             : 
   18060         278 :     q = createPQExpBuffer();
   18061         278 :     delq = createPQExpBuffer();
   18062         278 :     query = createPQExpBuffer();
   18063             : 
   18064         278 :     qstatsextname = pg_strdup(fmtId(statsextinfo->dobj.name));
   18065             : 
   18066         278 :     appendPQExpBuffer(query, "SELECT "
   18067             :                       "pg_catalog.pg_get_statisticsobjdef('%u'::pg_catalog.oid)",
   18068             :                       statsextinfo->dobj.catId.oid);
   18069             : 
   18070         278 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   18071             : 
   18072         278 :     stxdef = PQgetvalue(res, 0, 0);
   18073             : 
   18074             :     /* Result of pg_get_statisticsobjdef is complete except for semicolon */
   18075         278 :     appendPQExpBuffer(q, "%s;\n", stxdef);
   18076             : 
   18077             :     /*
   18078             :      * We only issue an ALTER STATISTICS statement if the stxstattarget entry
   18079             :      * for this statistics object is not the default value.
   18080             :      */
   18081         278 :     if (statsextinfo->stattarget >= 0)
   18082             :     {
   18083          72 :         appendPQExpBuffer(q, "ALTER STATISTICS %s ",
   18084          72 :                           fmtQualifiedDumpable(statsextinfo));
   18085          72 :         appendPQExpBuffer(q, "SET STATISTICS %d;\n",
   18086             :                           statsextinfo->stattarget);
   18087             :     }
   18088             : 
   18089         278 :     appendPQExpBuffer(delq, "DROP STATISTICS %s;\n",
   18090         278 :                       fmtQualifiedDumpable(statsextinfo));
   18091             : 
   18092         278 :     if (statsextinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18093         278 :         ArchiveEntry(fout, statsextinfo->dobj.catId,
   18094             :                      statsextinfo->dobj.dumpId,
   18095         278 :                      ARCHIVE_OPTS(.tag = statsextinfo->dobj.name,
   18096             :                                   .namespace = statsextinfo->dobj.namespace->dobj.name,
   18097             :                                   .owner = statsextinfo->rolname,
   18098             :                                   .description = "STATISTICS",
   18099             :                                   .section = SECTION_POST_DATA,
   18100             :                                   .createStmt = q->data,
   18101             :                                   .dropStmt = delq->data));
   18102             : 
   18103             :     /* Dump Statistics Comments */
   18104         278 :     if (statsextinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   18105           0 :         dumpComment(fout, "STATISTICS", qstatsextname,
   18106           0 :                     statsextinfo->dobj.namespace->dobj.name,
   18107             :                     statsextinfo->rolname,
   18108             :                     statsextinfo->dobj.catId, 0,
   18109             :                     statsextinfo->dobj.dumpId);
   18110             : 
   18111         278 :     PQclear(res);
   18112         278 :     destroyPQExpBuffer(q);
   18113         278 :     destroyPQExpBuffer(delq);
   18114         278 :     destroyPQExpBuffer(query);
   18115         278 :     free(qstatsextname);
   18116             : }
   18117             : 
   18118             : /*
   18119             :  * dumpConstraint
   18120             :  *    write out to fout a user-defined constraint
   18121             :  */
   18122             : static void
   18123        6338 : dumpConstraint(Archive *fout, const ConstraintInfo *coninfo)
   18124             : {
   18125        6338 :     DumpOptions *dopt = fout->dopt;
   18126        6338 :     TableInfo  *tbinfo = coninfo->contable;
   18127             :     PQExpBuffer q;
   18128             :     PQExpBuffer delq;
   18129        6338 :     char       *tag = NULL;
   18130             :     char       *foreign;
   18131             : 
   18132             :     /* Do nothing if not dumping schema */
   18133        6338 :     if (!dopt->dumpSchema)
   18134         184 :         return;
   18135             : 
   18136        6154 :     q = createPQExpBuffer();
   18137        6154 :     delq = createPQExpBuffer();
   18138             : 
   18139       12012 :     foreign = tbinfo &&
   18140        6154 :         tbinfo->relkind == RELKIND_FOREIGN_TABLE ? "FOREIGN " : "";
   18141             : 
   18142        6154 :     if (coninfo->contype == 'p' ||
   18143        2988 :         coninfo->contype == 'u' ||
   18144        2480 :         coninfo->contype == 'x')
   18145        3706 :     {
   18146             :         /* Index-related constraint */
   18147             :         IndxInfo   *indxinfo;
   18148             :         int         k;
   18149             : 
   18150        3706 :         indxinfo = (IndxInfo *) findObjectByDumpId(coninfo->conindex);
   18151             : 
   18152        3706 :         if (indxinfo == NULL)
   18153           0 :             pg_fatal("missing index for constraint \"%s\"",
   18154             :                      coninfo->dobj.name);
   18155             : 
   18156        3706 :         if (dopt->binary_upgrade)
   18157         288 :             binary_upgrade_set_pg_class_oids(fout, q,
   18158             :                                              indxinfo->dobj.catId.oid);
   18159             : 
   18160        3706 :         appendPQExpBuffer(q, "ALTER %sTABLE ONLY %s\n", foreign,
   18161        3706 :                           fmtQualifiedDumpable(tbinfo));
   18162        3706 :         appendPQExpBuffer(q, "    ADD CONSTRAINT %s ",
   18163        3706 :                           fmtId(coninfo->dobj.name));
   18164             : 
   18165        3706 :         if (coninfo->condef)
   18166             :         {
   18167             :             /* pg_get_constraintdef should have provided everything */
   18168          32 :             appendPQExpBuffer(q, "%s;\n", coninfo->condef);
   18169             :         }
   18170             :         else
   18171             :         {
   18172        3674 :             appendPQExpBufferStr(q,
   18173        3674 :                                  coninfo->contype == 'p' ? "PRIMARY KEY" : "UNIQUE");
   18174             : 
   18175             :             /*
   18176             :              * PRIMARY KEY constraints should not be using NULLS NOT DISTINCT
   18177             :              * indexes. Being able to create this was fixed, but we need to
   18178             :              * make the index distinct in order to be able to restore the
   18179             :              * dump.
   18180             :              */
   18181        3674 :             if (indxinfo->indnullsnotdistinct && coninfo->contype != 'p')
   18182           0 :                 appendPQExpBufferStr(q, " NULLS NOT DISTINCT");
   18183        3674 :             appendPQExpBufferStr(q, " (");
   18184        8734 :             for (k = 0; k < indxinfo->indnkeyattrs; k++)
   18185             :             {
   18186        5060 :                 int         indkey = (int) indxinfo->indkeys[k];
   18187             :                 const char *attname;
   18188             : 
   18189        5060 :                 if (indkey == InvalidAttrNumber)
   18190           0 :                     break;
   18191        5060 :                 attname = getAttrName(indkey, tbinfo);
   18192             : 
   18193        5060 :                 appendPQExpBuffer(q, "%s%s",
   18194             :                                   (k == 0) ? "" : ", ",
   18195             :                                   fmtId(attname));
   18196             :             }
   18197        3674 :             if (coninfo->conperiod)
   18198         272 :                 appendPQExpBufferStr(q, " WITHOUT OVERLAPS");
   18199             : 
   18200        3674 :             if (indxinfo->indnkeyattrs < indxinfo->indnattrs)
   18201          64 :                 appendPQExpBufferStr(q, ") INCLUDE (");
   18202             : 
   18203        3802 :             for (k = indxinfo->indnkeyattrs; k < indxinfo->indnattrs; k++)
   18204             :             {
   18205         128 :                 int         indkey = (int) indxinfo->indkeys[k];
   18206             :                 const char *attname;
   18207             : 
   18208         128 :                 if (indkey == InvalidAttrNumber)
   18209           0 :                     break;
   18210         128 :                 attname = getAttrName(indkey, tbinfo);
   18211             : 
   18212         256 :                 appendPQExpBuffer(q, "%s%s",
   18213         128 :                                   (k == indxinfo->indnkeyattrs) ? "" : ", ",
   18214             :                                   fmtId(attname));
   18215             :             }
   18216             : 
   18217        3674 :             appendPQExpBufferChar(q, ')');
   18218             : 
   18219        3674 :             if (nonemptyReloptions(indxinfo->indreloptions))
   18220             :             {
   18221           0 :                 appendPQExpBufferStr(q, " WITH (");
   18222           0 :                 appendReloptionsArrayAH(q, indxinfo->indreloptions, "", fout);
   18223           0 :                 appendPQExpBufferChar(q, ')');
   18224             :             }
   18225             : 
   18226        3674 :             if (coninfo->condeferrable)
   18227             :             {
   18228          80 :                 appendPQExpBufferStr(q, " DEFERRABLE");
   18229          80 :                 if (coninfo->condeferred)
   18230          48 :                     appendPQExpBufferStr(q, " INITIALLY DEFERRED");
   18231             :             }
   18232             : 
   18233        3674 :             appendPQExpBufferStr(q, ";\n");
   18234             :         }
   18235             : 
   18236             :         /*
   18237             :          * Append ALTER TABLE commands as needed to set properties that we
   18238             :          * only have ALTER TABLE syntax for.  Keep this in sync with the
   18239             :          * similar code in dumpIndex!
   18240             :          */
   18241             : 
   18242             :         /* If the index is clustered, we need to record that. */
   18243        3706 :         if (indxinfo->indisclustered)
   18244             :         {
   18245          72 :             appendPQExpBuffer(q, "\nALTER TABLE %s CLUSTER",
   18246          72 :                               fmtQualifiedDumpable(tbinfo));
   18247             :             /* index name is not qualified in this syntax */
   18248          72 :             appendPQExpBuffer(q, " ON %s;\n",
   18249          72 :                               fmtId(indxinfo->dobj.name));
   18250             :         }
   18251             : 
   18252             :         /* If the index defines identity, we need to record that. */
   18253        3706 :         if (indxinfo->indisreplident)
   18254             :         {
   18255           0 :             appendPQExpBuffer(q, "\nALTER TABLE ONLY %s REPLICA IDENTITY USING",
   18256           0 :                               fmtQualifiedDumpable(tbinfo));
   18257             :             /* index name is not qualified in this syntax */
   18258           0 :             appendPQExpBuffer(q, " INDEX %s;\n",
   18259           0 :                               fmtId(indxinfo->dobj.name));
   18260             :         }
   18261             : 
   18262             :         /* Indexes can depend on extensions */
   18263        3706 :         append_depends_on_extension(fout, q, &indxinfo->dobj,
   18264             :                                     "pg_catalog.pg_class", "INDEX",
   18265        3706 :                                     fmtQualifiedDumpable(indxinfo));
   18266             : 
   18267        3706 :         appendPQExpBuffer(delq, "ALTER %sTABLE ONLY %s ", foreign,
   18268        3706 :                           fmtQualifiedDumpable(tbinfo));
   18269        3706 :         appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
   18270        3706 :                           fmtId(coninfo->dobj.name));
   18271             : 
   18272        3706 :         tag = psprintf("%s %s", tbinfo->dobj.name, coninfo->dobj.name);
   18273             : 
   18274        3706 :         if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18275        3706 :             ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
   18276        3706 :                          ARCHIVE_OPTS(.tag = tag,
   18277             :                                       .namespace = tbinfo->dobj.namespace->dobj.name,
   18278             :                                       .tablespace = indxinfo->tablespace,
   18279             :                                       .owner = tbinfo->rolname,
   18280             :                                       .description = "CONSTRAINT",
   18281             :                                       .section = SECTION_POST_DATA,
   18282             :                                       .createStmt = q->data,
   18283             :                                       .dropStmt = delq->data));
   18284             :     }
   18285        2448 :     else if (coninfo->contype == 'f')
   18286             :     {
   18287             :         char       *only;
   18288             : 
   18289             :         /*
   18290             :          * Foreign keys on partitioned tables are always declared as
   18291             :          * inheriting to partitions; for all other cases, emit them as
   18292             :          * applying ONLY directly to the named table, because that's how they
   18293             :          * work for regular inherited tables.
   18294             :          */
   18295         448 :         only = tbinfo->relkind == RELKIND_PARTITIONED_TABLE ? "" : "ONLY ";
   18296             : 
   18297             :         /*
   18298             :          * XXX Potentially wrap in a 'SET CONSTRAINTS OFF' block so that the
   18299             :          * current table data is not processed
   18300             :          */
   18301         448 :         appendPQExpBuffer(q, "ALTER %sTABLE %s%s\n", foreign,
   18302         448 :                           only, fmtQualifiedDumpable(tbinfo));
   18303         448 :         appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
   18304         448 :                           fmtId(coninfo->dobj.name),
   18305             :                           coninfo->condef);
   18306             : 
   18307         448 :         appendPQExpBuffer(delq, "ALTER %sTABLE %s%s ", foreign,
   18308         448 :                           only, fmtQualifiedDumpable(tbinfo));
   18309         448 :         appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
   18310         448 :                           fmtId(coninfo->dobj.name));
   18311             : 
   18312         448 :         tag = psprintf("%s %s", tbinfo->dobj.name, coninfo->dobj.name);
   18313             : 
   18314         448 :         if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18315         448 :             ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
   18316         448 :                          ARCHIVE_OPTS(.tag = tag,
   18317             :                                       .namespace = tbinfo->dobj.namespace->dobj.name,
   18318             :                                       .owner = tbinfo->rolname,
   18319             :                                       .description = "FK CONSTRAINT",
   18320             :                                       .section = SECTION_POST_DATA,
   18321             :                                       .createStmt = q->data,
   18322             :                                       .dropStmt = delq->data));
   18323             :     }
   18324        2000 :     else if ((coninfo->contype == 'c' || coninfo->contype == 'n') && tbinfo)
   18325             :     {
   18326             :         /* CHECK or invalid not-null constraint on a table */
   18327             : 
   18328             :         /* Ignore if not to be dumped separately, or if it was inherited */
   18329        1704 :         if (coninfo->separate && coninfo->conislocal)
   18330             :         {
   18331             :             const char *keyword;
   18332             : 
   18333         280 :             if (coninfo->contype == 'c')
   18334         144 :                 keyword = "CHECK CONSTRAINT";
   18335             :             else
   18336         136 :                 keyword = "CONSTRAINT";
   18337             : 
   18338             :             /* not ONLY since we want it to propagate to children */
   18339         280 :             appendPQExpBuffer(q, "ALTER %sTABLE %s\n", foreign,
   18340         280 :                               fmtQualifiedDumpable(tbinfo));
   18341         280 :             appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
   18342         280 :                               fmtId(coninfo->dobj.name),
   18343             :                               coninfo->condef);
   18344             : 
   18345         280 :             appendPQExpBuffer(delq, "ALTER %sTABLE %s ", foreign,
   18346         280 :                               fmtQualifiedDumpable(tbinfo));
   18347         280 :             appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
   18348         280 :                               fmtId(coninfo->dobj.name));
   18349             : 
   18350         280 :             tag = psprintf("%s %s", tbinfo->dobj.name, coninfo->dobj.name);
   18351             : 
   18352         280 :             if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18353         280 :                 ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
   18354         280 :                              ARCHIVE_OPTS(.tag = tag,
   18355             :                                           .namespace = tbinfo->dobj.namespace->dobj.name,
   18356             :                                           .owner = tbinfo->rolname,
   18357             :                                           .description = keyword,
   18358             :                                           .section = SECTION_POST_DATA,
   18359             :                                           .createStmt = q->data,
   18360             :                                           .dropStmt = delq->data));
   18361             :         }
   18362             :     }
   18363         296 :     else if (coninfo->contype == 'c' && tbinfo == NULL)
   18364         296 :     {
   18365             :         /* CHECK constraint on a domain */
   18366         296 :         TypeInfo   *tyinfo = coninfo->condomain;
   18367             : 
   18368             :         /* Ignore if not to be dumped separately */
   18369         296 :         if (coninfo->separate)
   18370             :         {
   18371           0 :             appendPQExpBuffer(q, "ALTER DOMAIN %s\n",
   18372           0 :                               fmtQualifiedDumpable(tyinfo));
   18373           0 :             appendPQExpBuffer(q, "    ADD CONSTRAINT %s %s;\n",
   18374           0 :                               fmtId(coninfo->dobj.name),
   18375             :                               coninfo->condef);
   18376             : 
   18377           0 :             appendPQExpBuffer(delq, "ALTER DOMAIN %s ",
   18378           0 :                               fmtQualifiedDumpable(tyinfo));
   18379           0 :             appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
   18380           0 :                               fmtId(coninfo->dobj.name));
   18381             : 
   18382           0 :             tag = psprintf("%s %s", tyinfo->dobj.name, coninfo->dobj.name);
   18383             : 
   18384           0 :             if (coninfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18385           0 :                 ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
   18386           0 :                              ARCHIVE_OPTS(.tag = tag,
   18387             :                                           .namespace = tyinfo->dobj.namespace->dobj.name,
   18388             :                                           .owner = tyinfo->rolname,
   18389             :                                           .description = "CHECK CONSTRAINT",
   18390             :                                           .section = SECTION_POST_DATA,
   18391             :                                           .createStmt = q->data,
   18392             :                                           .dropStmt = delq->data));
   18393             :         }
   18394             :     }
   18395             :     else
   18396             :     {
   18397           0 :         pg_fatal("unrecognized constraint type: %c",
   18398             :                  coninfo->contype);
   18399             :     }
   18400             : 
   18401             :     /* Dump Constraint Comments --- only works for table constraints */
   18402        6154 :     if (tbinfo && coninfo->separate &&
   18403        4530 :         coninfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   18404          32 :         dumpTableConstraintComment(fout, coninfo);
   18405             : 
   18406        6154 :     free(tag);
   18407        6154 :     destroyPQExpBuffer(q);
   18408        6154 :     destroyPQExpBuffer(delq);
   18409             : }
   18410             : 
   18411             : /*
   18412             :  * dumpTableConstraintComment --- dump a constraint's comment if any
   18413             :  *
   18414             :  * This is split out because we need the function in two different places
   18415             :  * depending on whether the constraint is dumped as part of CREATE TABLE
   18416             :  * or as a separate ALTER command.
   18417             :  */
   18418             : static void
   18419         120 : dumpTableConstraintComment(Archive *fout, const ConstraintInfo *coninfo)
   18420             : {
   18421         120 :     TableInfo  *tbinfo = coninfo->contable;
   18422         120 :     PQExpBuffer conprefix = createPQExpBuffer();
   18423             :     char       *qtabname;
   18424             : 
   18425         120 :     qtabname = pg_strdup(fmtId(tbinfo->dobj.name));
   18426             : 
   18427         120 :     appendPQExpBuffer(conprefix, "CONSTRAINT %s ON",
   18428         120 :                       fmtId(coninfo->dobj.name));
   18429             : 
   18430         120 :     if (coninfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   18431         120 :         dumpComment(fout, conprefix->data, qtabname,
   18432         120 :                     tbinfo->dobj.namespace->dobj.name,
   18433             :                     tbinfo->rolname,
   18434             :                     coninfo->dobj.catId, 0,
   18435         120 :                     coninfo->separate ? coninfo->dobj.dumpId : tbinfo->dobj.dumpId);
   18436             : 
   18437         120 :     destroyPQExpBuffer(conprefix);
   18438         120 :     free(qtabname);
   18439         120 : }
   18440             : 
   18441             : static inline SeqType
   18442        1632 : parse_sequence_type(const char *name)
   18443             : {
   18444        3612 :     for (int i = 0; i < lengthof(SeqTypeNames); i++)
   18445             :     {
   18446        3612 :         if (strcmp(SeqTypeNames[i], name) == 0)
   18447        1632 :             return (SeqType) i;
   18448             :     }
   18449             : 
   18450           0 :     pg_fatal("unrecognized sequence type: %s", name);
   18451             :     return (SeqType) 0;         /* keep compiler quiet */
   18452             : }
   18453             : 
   18454             : /*
   18455             :  * bsearch() comparator for SequenceItem
   18456             :  */
   18457             : static int
   18458        9138 : SequenceItemCmp(const void *p1, const void *p2)
   18459             : {
   18460        9138 :     SequenceItem v1 = *((const SequenceItem *) p1);
   18461        9138 :     SequenceItem v2 = *((const SequenceItem *) p2);
   18462             : 
   18463        9138 :     return pg_cmp_u32(v1.oid, v2.oid);
   18464             : }
   18465             : 
   18466             : /*
   18467             :  * collectSequences
   18468             :  *
   18469             :  * Construct a table of sequence information.  This table is sorted by OID for
   18470             :  * speed in lookup.
   18471             :  */
   18472             : static void
   18473         468 : collectSequences(Archive *fout)
   18474             : {
   18475             :     PGresult   *res;
   18476             :     const char *query;
   18477             : 
   18478             :     /*
   18479             :      * Before Postgres 10, sequence metadata is in the sequence itself.  With
   18480             :      * some extra effort, we might be able to use the sorted table for those
   18481             :      * versions, but for now it seems unlikely to be worth it.
   18482             :      *
   18483             :      * Since version 18, we can gather the sequence data in this query with
   18484             :      * pg_get_sequence_data(), but we only do so for non-schema-only dumps.
   18485             :      */
   18486         468 :     if (fout->remoteVersion < 100000)
   18487           0 :         return;
   18488         468 :     else if (fout->remoteVersion < 180000 ||
   18489         468 :              (!fout->dopt->dumpData && !fout->dopt->sequence_data))
   18490          16 :         query = "SELECT seqrelid, format_type(seqtypid, NULL), "
   18491             :             "seqstart, seqincrement, "
   18492             :             "seqmax, seqmin, "
   18493             :             "seqcache, seqcycle, "
   18494             :             "NULL, 'f' "
   18495             :             "FROM pg_catalog.pg_sequence "
   18496             :             "ORDER BY seqrelid";
   18497             :     else
   18498         452 :         query = "SELECT seqrelid, format_type(seqtypid, NULL), "
   18499             :             "seqstart, seqincrement, "
   18500             :             "seqmax, seqmin, "
   18501             :             "seqcache, seqcycle, "
   18502             :             "last_value, is_called "
   18503             :             "FROM pg_catalog.pg_sequence, "
   18504             :             "pg_get_sequence_data(seqrelid) "
   18505             :             "ORDER BY seqrelid;";
   18506             : 
   18507         468 :     res = ExecuteSqlQuery(fout, query, PGRES_TUPLES_OK);
   18508             : 
   18509         468 :     nsequences = PQntuples(res);
   18510         468 :     sequences = (SequenceItem *) pg_malloc(nsequences * sizeof(SequenceItem));
   18511             : 
   18512        2100 :     for (int i = 0; i < nsequences; i++)
   18513             :     {
   18514        1632 :         sequences[i].oid = atooid(PQgetvalue(res, i, 0));
   18515        1632 :         sequences[i].seqtype = parse_sequence_type(PQgetvalue(res, i, 1));
   18516        1632 :         sequences[i].startv = strtoi64(PQgetvalue(res, i, 2), NULL, 10);
   18517        1632 :         sequences[i].incby = strtoi64(PQgetvalue(res, i, 3), NULL, 10);
   18518        1632 :         sequences[i].maxv = strtoi64(PQgetvalue(res, i, 4), NULL, 10);
   18519        1632 :         sequences[i].minv = strtoi64(PQgetvalue(res, i, 5), NULL, 10);
   18520        1632 :         sequences[i].cache = strtoi64(PQgetvalue(res, i, 6), NULL, 10);
   18521        1632 :         sequences[i].cycled = (strcmp(PQgetvalue(res, i, 7), "t") == 0);
   18522        1632 :         sequences[i].last_value = strtoi64(PQgetvalue(res, i, 8), NULL, 10);
   18523        1632 :         sequences[i].is_called = (strcmp(PQgetvalue(res, i, 9), "t") == 0);
   18524             :     }
   18525             : 
   18526         468 :     PQclear(res);
   18527             : }
   18528             : 
   18529             : /*
   18530             :  * dumpSequence
   18531             :  *    write the declaration (not data) of one user-defined sequence
   18532             :  */
   18533             : static void
   18534        1106 : dumpSequence(Archive *fout, const TableInfo *tbinfo)
   18535             : {
   18536        1106 :     DumpOptions *dopt = fout->dopt;
   18537             :     SequenceItem *seq;
   18538             :     bool        is_ascending;
   18539             :     int64       default_minv,
   18540             :                 default_maxv;
   18541        1106 :     PQExpBuffer query = createPQExpBuffer();
   18542        1106 :     PQExpBuffer delqry = createPQExpBuffer();
   18543             :     char       *qseqname;
   18544        1106 :     TableInfo  *owning_tab = NULL;
   18545             : 
   18546        1106 :     qseqname = pg_strdup(fmtId(tbinfo->dobj.name));
   18547             : 
   18548             :     /*
   18549             :      * For versions >= 10, the sequence information is gathered in a sorted
   18550             :      * table before any calls to dumpSequence().  See collectSequences() for
   18551             :      * more information.
   18552             :      */
   18553        1106 :     if (fout->remoteVersion >= 100000)
   18554             :     {
   18555        1106 :         SequenceItem key = {0};
   18556             : 
   18557             :         Assert(sequences);
   18558             : 
   18559        1106 :         key.oid = tbinfo->dobj.catId.oid;
   18560        1106 :         seq = bsearch(&key, sequences, nsequences,
   18561             :                       sizeof(SequenceItem), SequenceItemCmp);
   18562             :     }
   18563             :     else
   18564             :     {
   18565             :         PGresult   *res;
   18566             : 
   18567             :         /*
   18568             :          * Before PostgreSQL 10, sequence metadata is in the sequence itself.
   18569             :          *
   18570             :          * Note: it might seem that 'bigint' potentially needs to be
   18571             :          * schema-qualified, but actually that's a keyword.
   18572             :          */
   18573           0 :         appendPQExpBuffer(query,
   18574             :                           "SELECT 'bigint' AS sequence_type, "
   18575             :                           "start_value, increment_by, max_value, min_value, "
   18576             :                           "cache_value, is_cycled FROM %s",
   18577           0 :                           fmtQualifiedDumpable(tbinfo));
   18578             : 
   18579           0 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   18580             : 
   18581           0 :         if (PQntuples(res) != 1)
   18582           0 :             pg_fatal(ngettext("query to get data of sequence \"%s\" returned %d row (expected 1)",
   18583             :                               "query to get data of sequence \"%s\" returned %d rows (expected 1)",
   18584             :                               PQntuples(res)),
   18585             :                      tbinfo->dobj.name, PQntuples(res));
   18586             : 
   18587           0 :         seq = pg_malloc0(sizeof(SequenceItem));
   18588           0 :         seq->seqtype = parse_sequence_type(PQgetvalue(res, 0, 0));
   18589           0 :         seq->startv = strtoi64(PQgetvalue(res, 0, 1), NULL, 10);
   18590           0 :         seq->incby = strtoi64(PQgetvalue(res, 0, 2), NULL, 10);
   18591           0 :         seq->maxv = strtoi64(PQgetvalue(res, 0, 3), NULL, 10);
   18592           0 :         seq->minv = strtoi64(PQgetvalue(res, 0, 4), NULL, 10);
   18593           0 :         seq->cache = strtoi64(PQgetvalue(res, 0, 5), NULL, 10);
   18594           0 :         seq->cycled = (strcmp(PQgetvalue(res, 0, 6), "t") == 0);
   18595             : 
   18596           0 :         PQclear(res);
   18597             :     }
   18598             : 
   18599             :     /* Calculate default limits for a sequence of this type */
   18600        1106 :     is_ascending = (seq->incby >= 0);
   18601        1106 :     if (seq->seqtype == SEQTYPE_SMALLINT)
   18602             :     {
   18603          80 :         default_minv = is_ascending ? 1 : PG_INT16_MIN;
   18604          80 :         default_maxv = is_ascending ? PG_INT16_MAX : -1;
   18605             :     }
   18606        1026 :     else if (seq->seqtype == SEQTYPE_INTEGER)
   18607             :     {
   18608         814 :         default_minv = is_ascending ? 1 : PG_INT32_MIN;
   18609         814 :         default_maxv = is_ascending ? PG_INT32_MAX : -1;
   18610             :     }
   18611         212 :     else if (seq->seqtype == SEQTYPE_BIGINT)
   18612             :     {
   18613         212 :         default_minv = is_ascending ? 1 : PG_INT64_MIN;
   18614         212 :         default_maxv = is_ascending ? PG_INT64_MAX : -1;
   18615             :     }
   18616             :     else
   18617             :     {
   18618           0 :         pg_fatal("unrecognized sequence type: %d", seq->seqtype);
   18619             :         default_minv = default_maxv = 0;    /* keep compiler quiet */
   18620             :     }
   18621             : 
   18622             :     /*
   18623             :      * Identity sequences are not to be dropped separately.
   18624             :      */
   18625        1106 :     if (!tbinfo->is_identity_sequence)
   18626             :     {
   18627         682 :         appendPQExpBuffer(delqry, "DROP SEQUENCE %s;\n",
   18628         682 :                           fmtQualifiedDumpable(tbinfo));
   18629             :     }
   18630             : 
   18631        1106 :     resetPQExpBuffer(query);
   18632             : 
   18633        1106 :     if (dopt->binary_upgrade)
   18634             :     {
   18635         132 :         binary_upgrade_set_pg_class_oids(fout, query,
   18636             :                                          tbinfo->dobj.catId.oid);
   18637             : 
   18638             :         /*
   18639             :          * In older PG versions a sequence will have a pg_type entry, but v14
   18640             :          * and up don't use that, so don't attempt to preserve the type OID.
   18641             :          */
   18642             :     }
   18643             : 
   18644        1106 :     if (tbinfo->is_identity_sequence)
   18645             :     {
   18646         424 :         owning_tab = findTableByOid(tbinfo->owning_tab);
   18647             : 
   18648         424 :         appendPQExpBuffer(query,
   18649             :                           "ALTER TABLE %s ",
   18650         424 :                           fmtQualifiedDumpable(owning_tab));
   18651         424 :         appendPQExpBuffer(query,
   18652             :                           "ALTER COLUMN %s ADD GENERATED ",
   18653         424 :                           fmtId(owning_tab->attnames[tbinfo->owning_col - 1]));
   18654         424 :         if (owning_tab->attidentity[tbinfo->owning_col - 1] == ATTRIBUTE_IDENTITY_ALWAYS)
   18655         296 :             appendPQExpBufferStr(query, "ALWAYS");
   18656         128 :         else if (owning_tab->attidentity[tbinfo->owning_col - 1] == ATTRIBUTE_IDENTITY_BY_DEFAULT)
   18657         128 :             appendPQExpBufferStr(query, "BY DEFAULT");
   18658         424 :         appendPQExpBuffer(query, " AS IDENTITY (\n    SEQUENCE NAME %s\n",
   18659         424 :                           fmtQualifiedDumpable(tbinfo));
   18660             : 
   18661             :         /*
   18662             :          * Emit persistence option only if it's different from the owning
   18663             :          * table's.  This avoids using this new syntax unnecessarily.
   18664             :          */
   18665         424 :         if (tbinfo->relpersistence != owning_tab->relpersistence)
   18666          32 :             appendPQExpBuffer(query, "    %s\n",
   18667          32 :                               tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED ?
   18668             :                               "UNLOGGED" : "LOGGED");
   18669             :     }
   18670             :     else
   18671             :     {
   18672         682 :         appendPQExpBuffer(query,
   18673             :                           "CREATE %sSEQUENCE %s\n",
   18674         682 :                           tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED ?
   18675             :                           "UNLOGGED " : "",
   18676         682 :                           fmtQualifiedDumpable(tbinfo));
   18677             : 
   18678         682 :         if (seq->seqtype != SEQTYPE_BIGINT)
   18679         518 :             appendPQExpBuffer(query, "    AS %s\n", SeqTypeNames[seq->seqtype]);
   18680             :     }
   18681             : 
   18682        1106 :     appendPQExpBuffer(query, "    START WITH " INT64_FORMAT "\n", seq->startv);
   18683             : 
   18684        1106 :     appendPQExpBuffer(query, "    INCREMENT BY " INT64_FORMAT "\n", seq->incby);
   18685             : 
   18686        1106 :     if (seq->minv != default_minv)
   18687          48 :         appendPQExpBuffer(query, "    MINVALUE " INT64_FORMAT "\n", seq->minv);
   18688             :     else
   18689        1058 :         appendPQExpBufferStr(query, "    NO MINVALUE\n");
   18690             : 
   18691        1106 :     if (seq->maxv != default_maxv)
   18692          48 :         appendPQExpBuffer(query, "    MAXVALUE " INT64_FORMAT "\n", seq->maxv);
   18693             :     else
   18694        1058 :         appendPQExpBufferStr(query, "    NO MAXVALUE\n");
   18695             : 
   18696        1106 :     appendPQExpBuffer(query,
   18697             :                       "    CACHE " INT64_FORMAT "%s",
   18698        1106 :                       seq->cache, (seq->cycled ? "\n    CYCLE" : ""));
   18699             : 
   18700        1106 :     if (tbinfo->is_identity_sequence)
   18701         424 :         appendPQExpBufferStr(query, "\n);\n");
   18702             :     else
   18703         682 :         appendPQExpBufferStr(query, ";\n");
   18704             : 
   18705             :     /* binary_upgrade:  no need to clear TOAST table oid */
   18706             : 
   18707        1106 :     if (dopt->binary_upgrade)
   18708         132 :         binary_upgrade_extension_member(query, &tbinfo->dobj,
   18709             :                                         "SEQUENCE", qseqname,
   18710         132 :                                         tbinfo->dobj.namespace->dobj.name);
   18711             : 
   18712        1106 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18713        1106 :         ArchiveEntry(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
   18714        1106 :                      ARCHIVE_OPTS(.tag = tbinfo->dobj.name,
   18715             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   18716             :                                   .owner = tbinfo->rolname,
   18717             :                                   .description = "SEQUENCE",
   18718             :                                   .section = SECTION_PRE_DATA,
   18719             :                                   .createStmt = query->data,
   18720             :                                   .dropStmt = delqry->data));
   18721             : 
   18722             :     /*
   18723             :      * If the sequence is owned by a table column, emit the ALTER for it as a
   18724             :      * separate TOC entry immediately following the sequence's own entry. It's
   18725             :      * OK to do this rather than using full sorting logic, because the
   18726             :      * dependency that tells us it's owned will have forced the table to be
   18727             :      * created first.  We can't just include the ALTER in the TOC entry
   18728             :      * because it will fail if we haven't reassigned the sequence owner to
   18729             :      * match the table's owner.
   18730             :      *
   18731             :      * We need not schema-qualify the table reference because both sequence
   18732             :      * and table must be in the same schema.
   18733             :      */
   18734        1106 :     if (OidIsValid(tbinfo->owning_tab) && !tbinfo->is_identity_sequence)
   18735             :     {
   18736         374 :         owning_tab = findTableByOid(tbinfo->owning_tab);
   18737             : 
   18738         374 :         if (owning_tab == NULL)
   18739           0 :             pg_fatal("failed sanity check, parent table with OID %u of sequence with OID %u not found",
   18740             :                      tbinfo->owning_tab, tbinfo->dobj.catId.oid);
   18741             : 
   18742         374 :         if (owning_tab->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18743             :         {
   18744         370 :             resetPQExpBuffer(query);
   18745         370 :             appendPQExpBuffer(query, "ALTER SEQUENCE %s",
   18746         370 :                               fmtQualifiedDumpable(tbinfo));
   18747         370 :             appendPQExpBuffer(query, " OWNED BY %s",
   18748         370 :                               fmtQualifiedDumpable(owning_tab));
   18749         370 :             appendPQExpBuffer(query, ".%s;\n",
   18750         370 :                               fmtId(owning_tab->attnames[tbinfo->owning_col - 1]));
   18751             : 
   18752         370 :             if (tbinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18753         370 :                 ArchiveEntry(fout, nilCatalogId, createDumpId(),
   18754         370 :                              ARCHIVE_OPTS(.tag = tbinfo->dobj.name,
   18755             :                                           .namespace = tbinfo->dobj.namespace->dobj.name,
   18756             :                                           .owner = tbinfo->rolname,
   18757             :                                           .description = "SEQUENCE OWNED BY",
   18758             :                                           .section = SECTION_PRE_DATA,
   18759             :                                           .createStmt = query->data,
   18760             :                                           .deps = &(tbinfo->dobj.dumpId),
   18761             :                                           .nDeps = 1));
   18762             :         }
   18763             :     }
   18764             : 
   18765             :     /* Dump Sequence Comments and Security Labels */
   18766        1106 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   18767           0 :         dumpComment(fout, "SEQUENCE", qseqname,
   18768           0 :                     tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
   18769             :                     tbinfo->dobj.catId, 0, tbinfo->dobj.dumpId);
   18770             : 
   18771        1106 :     if (tbinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
   18772           0 :         dumpSecLabel(fout, "SEQUENCE", qseqname,
   18773           0 :                      tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
   18774             :                      tbinfo->dobj.catId, 0, tbinfo->dobj.dumpId);
   18775             : 
   18776        1106 :     if (fout->remoteVersion < 100000)
   18777           0 :         pg_free(seq);
   18778        1106 :     destroyPQExpBuffer(query);
   18779        1106 :     destroyPQExpBuffer(delqry);
   18780        1106 :     free(qseqname);
   18781        1106 : }
   18782             : 
   18783             : /*
   18784             :  * dumpSequenceData
   18785             :  *    write the data of one user-defined sequence
   18786             :  */
   18787             : static void
   18788        1136 : dumpSequenceData(Archive *fout, const TableDataInfo *tdinfo)
   18789             : {
   18790        1136 :     TableInfo  *tbinfo = tdinfo->tdtable;
   18791             :     int64       last;
   18792             :     bool        called;
   18793        1136 :     PQExpBuffer query = createPQExpBuffer();
   18794             : 
   18795             :     /*
   18796             :      * For versions >= 18, the sequence information is gathered in the sorted
   18797             :      * array before any calls to dumpSequenceData().  See collectSequences()
   18798             :      * for more information.
   18799             :      *
   18800             :      * For older versions, we have to query the sequence relations
   18801             :      * individually.
   18802             :      */
   18803        1136 :     if (fout->remoteVersion < 180000)
   18804             :     {
   18805             :         PGresult   *res;
   18806             : 
   18807           0 :         appendPQExpBuffer(query,
   18808             :                           "SELECT last_value, is_called FROM %s",
   18809           0 :                           fmtQualifiedDumpable(tbinfo));
   18810             : 
   18811           0 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   18812             : 
   18813           0 :         if (PQntuples(res) != 1)
   18814           0 :             pg_fatal(ngettext("query to get data of sequence \"%s\" returned %d row (expected 1)",
   18815             :                               "query to get data of sequence \"%s\" returned %d rows (expected 1)",
   18816             :                               PQntuples(res)),
   18817             :                      tbinfo->dobj.name, PQntuples(res));
   18818             : 
   18819           0 :         last = strtoi64(PQgetvalue(res, 0, 0), NULL, 10);
   18820           0 :         called = (strcmp(PQgetvalue(res, 0, 1), "t") == 0);
   18821             : 
   18822           0 :         PQclear(res);
   18823             :     }
   18824             :     else
   18825             :     {
   18826        1136 :         SequenceItem key = {0};
   18827             :         SequenceItem *entry;
   18828             : 
   18829             :         Assert(sequences);
   18830             :         Assert(tbinfo->dobj.catId.oid);
   18831             : 
   18832        1136 :         key.oid = tbinfo->dobj.catId.oid;
   18833        1136 :         entry = bsearch(&key, sequences, nsequences,
   18834             :                         sizeof(SequenceItem), SequenceItemCmp);
   18835             : 
   18836        1136 :         last = entry->last_value;
   18837        1136 :         called = entry->is_called;
   18838             :     }
   18839             : 
   18840        1136 :     resetPQExpBuffer(query);
   18841        1136 :     appendPQExpBufferStr(query, "SELECT pg_catalog.setval(");
   18842        1136 :     appendStringLiteralAH(query, fmtQualifiedDumpable(tbinfo), fout);
   18843        1136 :     appendPQExpBuffer(query, ", " INT64_FORMAT ", %s);\n",
   18844             :                       last, (called ? "true" : "false"));
   18845             : 
   18846        1136 :     if (tdinfo->dobj.dump & DUMP_COMPONENT_DATA)
   18847        1136 :         ArchiveEntry(fout, nilCatalogId, createDumpId(),
   18848        1136 :                      ARCHIVE_OPTS(.tag = tbinfo->dobj.name,
   18849             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   18850             :                                   .owner = tbinfo->rolname,
   18851             :                                   .description = "SEQUENCE SET",
   18852             :                                   .section = SECTION_DATA,
   18853             :                                   .createStmt = query->data,
   18854             :                                   .deps = &(tbinfo->dobj.dumpId),
   18855             :                                   .nDeps = 1));
   18856             : 
   18857        1136 :     destroyPQExpBuffer(query);
   18858        1136 : }
   18859             : 
   18860             : /*
   18861             :  * dumpTrigger
   18862             :  *    write the declaration of one user-defined table trigger
   18863             :  */
   18864             : static void
   18865        1476 : dumpTrigger(Archive *fout, const TriggerInfo *tginfo)
   18866             : {
   18867        1476 :     DumpOptions *dopt = fout->dopt;
   18868        1476 :     TableInfo  *tbinfo = tginfo->tgtable;
   18869             :     PQExpBuffer query;
   18870             :     PQExpBuffer delqry;
   18871             :     PQExpBuffer trigprefix;
   18872             :     PQExpBuffer trigidentity;
   18873             :     char       *qtabname;
   18874             :     char       *tag;
   18875             : 
   18876             :     /* Do nothing if not dumping schema */
   18877        1476 :     if (!dopt->dumpSchema)
   18878          62 :         return;
   18879             : 
   18880        1414 :     query = createPQExpBuffer();
   18881        1414 :     delqry = createPQExpBuffer();
   18882        1414 :     trigprefix = createPQExpBuffer();
   18883        1414 :     trigidentity = createPQExpBuffer();
   18884             : 
   18885        1414 :     qtabname = pg_strdup(fmtId(tbinfo->dobj.name));
   18886             : 
   18887        1414 :     appendPQExpBuffer(trigidentity, "%s ", fmtId(tginfo->dobj.name));
   18888        1414 :     appendPQExpBuffer(trigidentity, "ON %s", fmtQualifiedDumpable(tbinfo));
   18889             : 
   18890        1414 :     appendPQExpBuffer(query, "%s;\n", tginfo->tgdef);
   18891        1414 :     appendPQExpBuffer(delqry, "DROP TRIGGER %s;\n", trigidentity->data);
   18892             : 
   18893             :     /* Triggers can depend on extensions */
   18894        1414 :     append_depends_on_extension(fout, query, &tginfo->dobj,
   18895             :                                 "pg_catalog.pg_trigger", "TRIGGER",
   18896        1414 :                                 trigidentity->data);
   18897             : 
   18898        1414 :     if (tginfo->tgispartition)
   18899             :     {
   18900             :         Assert(tbinfo->ispartition);
   18901             : 
   18902             :         /*
   18903             :          * Partition triggers only appear here because their 'tgenabled' flag
   18904             :          * differs from its parent's.  The trigger is created already, so
   18905             :          * remove the CREATE and replace it with an ALTER.  (Clear out the
   18906             :          * DROP query too, so that pg_dump --create does not cause errors.)
   18907             :          */
   18908         254 :         resetPQExpBuffer(query);
   18909         254 :         resetPQExpBuffer(delqry);
   18910         254 :         appendPQExpBuffer(query, "\nALTER %sTABLE %s ",
   18911         254 :                           tbinfo->relkind == RELKIND_FOREIGN_TABLE ? "FOREIGN " : "",
   18912         254 :                           fmtQualifiedDumpable(tbinfo));
   18913         254 :         switch (tginfo->tgenabled)
   18914             :         {
   18915          90 :             case 'f':
   18916             :             case 'D':
   18917          90 :                 appendPQExpBufferStr(query, "DISABLE");
   18918          90 :                 break;
   18919           0 :             case 't':
   18920             :             case 'O':
   18921           0 :                 appendPQExpBufferStr(query, "ENABLE");
   18922           0 :                 break;
   18923          74 :             case 'R':
   18924          74 :                 appendPQExpBufferStr(query, "ENABLE REPLICA");
   18925          74 :                 break;
   18926          90 :             case 'A':
   18927          90 :                 appendPQExpBufferStr(query, "ENABLE ALWAYS");
   18928          90 :                 break;
   18929             :         }
   18930         254 :         appendPQExpBuffer(query, " TRIGGER %s;\n",
   18931         254 :                           fmtId(tginfo->dobj.name));
   18932             :     }
   18933        1160 :     else if (tginfo->tgenabled != 't' && tginfo->tgenabled != 'O')
   18934             :     {
   18935           0 :         appendPQExpBuffer(query, "\nALTER %sTABLE %s ",
   18936           0 :                           tbinfo->relkind == RELKIND_FOREIGN_TABLE ? "FOREIGN " : "",
   18937           0 :                           fmtQualifiedDumpable(tbinfo));
   18938           0 :         switch (tginfo->tgenabled)
   18939             :         {
   18940           0 :             case 'D':
   18941             :             case 'f':
   18942           0 :                 appendPQExpBufferStr(query, "DISABLE");
   18943           0 :                 break;
   18944           0 :             case 'A':
   18945           0 :                 appendPQExpBufferStr(query, "ENABLE ALWAYS");
   18946           0 :                 break;
   18947           0 :             case 'R':
   18948           0 :                 appendPQExpBufferStr(query, "ENABLE REPLICA");
   18949           0 :                 break;
   18950           0 :             default:
   18951           0 :                 appendPQExpBufferStr(query, "ENABLE");
   18952           0 :                 break;
   18953             :         }
   18954           0 :         appendPQExpBuffer(query, " TRIGGER %s;\n",
   18955           0 :                           fmtId(tginfo->dobj.name));
   18956             :     }
   18957             : 
   18958        1414 :     appendPQExpBuffer(trigprefix, "TRIGGER %s ON",
   18959        1414 :                       fmtId(tginfo->dobj.name));
   18960             : 
   18961        1414 :     tag = psprintf("%s %s", tbinfo->dobj.name, tginfo->dobj.name);
   18962             : 
   18963        1414 :     if (tginfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   18964        1414 :         ArchiveEntry(fout, tginfo->dobj.catId, tginfo->dobj.dumpId,
   18965        1414 :                      ARCHIVE_OPTS(.tag = tag,
   18966             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   18967             :                                   .owner = tbinfo->rolname,
   18968             :                                   .description = "TRIGGER",
   18969             :                                   .section = SECTION_POST_DATA,
   18970             :                                   .createStmt = query->data,
   18971             :                                   .dropStmt = delqry->data));
   18972             : 
   18973        1414 :     if (tginfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   18974           0 :         dumpComment(fout, trigprefix->data, qtabname,
   18975           0 :                     tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
   18976             :                     tginfo->dobj.catId, 0, tginfo->dobj.dumpId);
   18977             : 
   18978        1414 :     free(tag);
   18979        1414 :     destroyPQExpBuffer(query);
   18980        1414 :     destroyPQExpBuffer(delqry);
   18981        1414 :     destroyPQExpBuffer(trigprefix);
   18982        1414 :     destroyPQExpBuffer(trigidentity);
   18983        1414 :     free(qtabname);
   18984             : }
   18985             : 
   18986             : /*
   18987             :  * dumpEventTrigger
   18988             :  *    write the declaration of one user-defined event trigger
   18989             :  */
   18990             : static void
   18991          98 : dumpEventTrigger(Archive *fout, const EventTriggerInfo *evtinfo)
   18992             : {
   18993          98 :     DumpOptions *dopt = fout->dopt;
   18994             :     PQExpBuffer query;
   18995             :     PQExpBuffer delqry;
   18996             :     char       *qevtname;
   18997             : 
   18998             :     /* Do nothing if not dumping schema */
   18999          98 :     if (!dopt->dumpSchema)
   19000          12 :         return;
   19001             : 
   19002          86 :     query = createPQExpBuffer();
   19003          86 :     delqry = createPQExpBuffer();
   19004             : 
   19005          86 :     qevtname = pg_strdup(fmtId(evtinfo->dobj.name));
   19006             : 
   19007          86 :     appendPQExpBufferStr(query, "CREATE EVENT TRIGGER ");
   19008          86 :     appendPQExpBufferStr(query, qevtname);
   19009          86 :     appendPQExpBufferStr(query, " ON ");
   19010          86 :     appendPQExpBufferStr(query, fmtId(evtinfo->evtevent));
   19011             : 
   19012          86 :     if (strcmp("", evtinfo->evttags) != 0)
   19013             :     {
   19014          16 :         appendPQExpBufferStr(query, "\n         WHEN TAG IN (");
   19015          16 :         appendPQExpBufferStr(query, evtinfo->evttags);
   19016          16 :         appendPQExpBufferChar(query, ')');
   19017             :     }
   19018             : 
   19019          86 :     appendPQExpBufferStr(query, "\n   EXECUTE FUNCTION ");
   19020          86 :     appendPQExpBufferStr(query, evtinfo->evtfname);
   19021          86 :     appendPQExpBufferStr(query, "();\n");
   19022             : 
   19023          86 :     if (evtinfo->evtenabled != 'O')
   19024             :     {
   19025           0 :         appendPQExpBuffer(query, "\nALTER EVENT TRIGGER %s ",
   19026             :                           qevtname);
   19027           0 :         switch (evtinfo->evtenabled)
   19028             :         {
   19029           0 :             case 'D':
   19030           0 :                 appendPQExpBufferStr(query, "DISABLE");
   19031           0 :                 break;
   19032           0 :             case 'A':
   19033           0 :                 appendPQExpBufferStr(query, "ENABLE ALWAYS");
   19034           0 :                 break;
   19035           0 :             case 'R':
   19036           0 :                 appendPQExpBufferStr(query, "ENABLE REPLICA");
   19037           0 :                 break;
   19038           0 :             default:
   19039           0 :                 appendPQExpBufferStr(query, "ENABLE");
   19040           0 :                 break;
   19041             :         }
   19042           0 :         appendPQExpBufferStr(query, ";\n");
   19043             :     }
   19044             : 
   19045          86 :     appendPQExpBuffer(delqry, "DROP EVENT TRIGGER %s;\n",
   19046             :                       qevtname);
   19047             : 
   19048          86 :     if (dopt->binary_upgrade)
   19049           4 :         binary_upgrade_extension_member(query, &evtinfo->dobj,
   19050             :                                         "EVENT TRIGGER", qevtname, NULL);
   19051             : 
   19052          86 :     if (evtinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   19053          86 :         ArchiveEntry(fout, evtinfo->dobj.catId, evtinfo->dobj.dumpId,
   19054          86 :                      ARCHIVE_OPTS(.tag = evtinfo->dobj.name,
   19055             :                                   .owner = evtinfo->evtowner,
   19056             :                                   .description = "EVENT TRIGGER",
   19057             :                                   .section = SECTION_POST_DATA,
   19058             :                                   .createStmt = query->data,
   19059             :                                   .dropStmt = delqry->data));
   19060             : 
   19061          86 :     if (evtinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   19062           0 :         dumpComment(fout, "EVENT TRIGGER", qevtname,
   19063             :                     NULL, evtinfo->evtowner,
   19064             :                     evtinfo->dobj.catId, 0, evtinfo->dobj.dumpId);
   19065             : 
   19066          86 :     destroyPQExpBuffer(query);
   19067          86 :     destroyPQExpBuffer(delqry);
   19068          86 :     free(qevtname);
   19069             : }
   19070             : 
   19071             : /*
   19072             :  * dumpRule
   19073             :  *      Dump a rule
   19074             :  */
   19075             : static void
   19076        2968 : dumpRule(Archive *fout, const RuleInfo *rinfo)
   19077             : {
   19078        2968 :     DumpOptions *dopt = fout->dopt;
   19079        2968 :     TableInfo  *tbinfo = rinfo->ruletable;
   19080             :     bool        is_view;
   19081             :     PQExpBuffer query;
   19082             :     PQExpBuffer cmd;
   19083             :     PQExpBuffer delcmd;
   19084             :     PQExpBuffer ruleprefix;
   19085             :     char       *qtabname;
   19086             :     PGresult   *res;
   19087             :     char       *tag;
   19088             : 
   19089             :     /* Do nothing if not dumping schema */
   19090        2968 :     if (!dopt->dumpSchema)
   19091         132 :         return;
   19092             : 
   19093             :     /*
   19094             :      * If it is an ON SELECT rule that is created implicitly by CREATE VIEW,
   19095             :      * we do not want to dump it as a separate object.
   19096             :      */
   19097        2836 :     if (!rinfo->separate)
   19098        2168 :         return;
   19099             : 
   19100             :     /*
   19101             :      * If it's an ON SELECT rule, we want to print it as a view definition,
   19102             :      * instead of a rule.
   19103             :      */
   19104         668 :     is_view = (rinfo->ev_type == '1' && rinfo->is_instead);
   19105             : 
   19106         668 :     query = createPQExpBuffer();
   19107         668 :     cmd = createPQExpBuffer();
   19108         668 :     delcmd = createPQExpBuffer();
   19109         668 :     ruleprefix = createPQExpBuffer();
   19110             : 
   19111         668 :     qtabname = pg_strdup(fmtId(tbinfo->dobj.name));
   19112             : 
   19113         668 :     if (is_view)
   19114             :     {
   19115             :         PQExpBuffer result;
   19116             : 
   19117             :         /*
   19118             :          * We need OR REPLACE here because we'll be replacing a dummy view.
   19119             :          * Otherwise this should look largely like the regular view dump code.
   19120             :          */
   19121          32 :         appendPQExpBuffer(cmd, "CREATE OR REPLACE VIEW %s",
   19122          32 :                           fmtQualifiedDumpable(tbinfo));
   19123          32 :         if (nonemptyReloptions(tbinfo->reloptions))
   19124             :         {
   19125           0 :             appendPQExpBufferStr(cmd, " WITH (");
   19126           0 :             appendReloptionsArrayAH(cmd, tbinfo->reloptions, "", fout);
   19127           0 :             appendPQExpBufferChar(cmd, ')');
   19128             :         }
   19129          32 :         result = createViewAsClause(fout, tbinfo);
   19130          32 :         appendPQExpBuffer(cmd, " AS\n%s", result->data);
   19131          32 :         destroyPQExpBuffer(result);
   19132          32 :         if (tbinfo->checkoption != NULL)
   19133           0 :             appendPQExpBuffer(cmd, "\n  WITH %s CHECK OPTION",
   19134             :                               tbinfo->checkoption);
   19135          32 :         appendPQExpBufferStr(cmd, ";\n");
   19136             :     }
   19137             :     else
   19138             :     {
   19139             :         /* In the rule case, just print pg_get_ruledef's result verbatim */
   19140         636 :         appendPQExpBuffer(query,
   19141             :                           "SELECT pg_catalog.pg_get_ruledef('%u'::pg_catalog.oid)",
   19142             :                           rinfo->dobj.catId.oid);
   19143             : 
   19144         636 :         res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   19145             : 
   19146         636 :         if (PQntuples(res) != 1)
   19147           0 :             pg_fatal("query to get rule \"%s\" for table \"%s\" failed: wrong number of rows returned",
   19148             :                      rinfo->dobj.name, tbinfo->dobj.name);
   19149             : 
   19150         636 :         printfPQExpBuffer(cmd, "%s\n", PQgetvalue(res, 0, 0));
   19151             : 
   19152         636 :         PQclear(res);
   19153             :     }
   19154             : 
   19155             :     /*
   19156             :      * Add the command to alter the rules replication firing semantics if it
   19157             :      * differs from the default.
   19158             :      */
   19159         668 :     if (rinfo->ev_enabled != 'O')
   19160             :     {
   19161          48 :         appendPQExpBuffer(cmd, "ALTER TABLE %s ", fmtQualifiedDumpable(tbinfo));
   19162          48 :         switch (rinfo->ev_enabled)
   19163             :         {
   19164           0 :             case 'A':
   19165           0 :                 appendPQExpBuffer(cmd, "ENABLE ALWAYS RULE %s;\n",
   19166           0 :                                   fmtId(rinfo->dobj.name));
   19167           0 :                 break;
   19168           0 :             case 'R':
   19169           0 :                 appendPQExpBuffer(cmd, "ENABLE REPLICA RULE %s;\n",
   19170           0 :                                   fmtId(rinfo->dobj.name));
   19171           0 :                 break;
   19172          48 :             case 'D':
   19173          48 :                 appendPQExpBuffer(cmd, "DISABLE RULE %s;\n",
   19174          48 :                                   fmtId(rinfo->dobj.name));
   19175          48 :                 break;
   19176             :         }
   19177         620 :     }
   19178             : 
   19179         668 :     if (is_view)
   19180             :     {
   19181             :         /*
   19182             :          * We can't DROP a view's ON SELECT rule.  Instead, use CREATE OR
   19183             :          * REPLACE VIEW to replace the rule with something with minimal
   19184             :          * dependencies.
   19185             :          */
   19186             :         PQExpBuffer result;
   19187             : 
   19188          32 :         appendPQExpBuffer(delcmd, "CREATE OR REPLACE VIEW %s",
   19189          32 :                           fmtQualifiedDumpable(tbinfo));
   19190          32 :         result = createDummyViewAsClause(fout, tbinfo);
   19191          32 :         appendPQExpBuffer(delcmd, " AS\n%s;\n", result->data);
   19192          32 :         destroyPQExpBuffer(result);
   19193             :     }
   19194             :     else
   19195             :     {
   19196         636 :         appendPQExpBuffer(delcmd, "DROP RULE %s ",
   19197         636 :                           fmtId(rinfo->dobj.name));
   19198         636 :         appendPQExpBuffer(delcmd, "ON %s;\n",
   19199         636 :                           fmtQualifiedDumpable(tbinfo));
   19200             :     }
   19201             : 
   19202         668 :     appendPQExpBuffer(ruleprefix, "RULE %s ON",
   19203         668 :                       fmtId(rinfo->dobj.name));
   19204             : 
   19205         668 :     tag = psprintf("%s %s", tbinfo->dobj.name, rinfo->dobj.name);
   19206             : 
   19207         668 :     if (rinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
   19208         668 :         ArchiveEntry(fout, rinfo->dobj.catId, rinfo->dobj.dumpId,
   19209         668 :                      ARCHIVE_OPTS(.tag = tag,
   19210             :                                   .namespace = tbinfo->dobj.namespace->dobj.name,
   19211             :                                   .owner = tbinfo->rolname,
   19212             :                                   .description = "RULE",
   19213             :                                   .section = SECTION_POST_DATA,
   19214             :                                   .createStmt = cmd->data,
   19215             :                                   .dropStmt = delcmd->data));
   19216             : 
   19217             :     /* Dump rule comments */
   19218         668 :     if (rinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
   19219           0 :         dumpComment(fout, ruleprefix->data, qtabname,
   19220           0 :                     tbinfo->dobj.namespace->dobj.name,
   19221             :                     tbinfo->rolname,
   19222             :                     rinfo->dobj.catId, 0, rinfo->dobj.dumpId);
   19223             : 
   19224         668 :     free(tag);
   19225         668 :     destroyPQExpBuffer(query);
   19226         668 :     destroyPQExpBuffer(cmd);
   19227         668 :     destroyPQExpBuffer(delcmd);
   19228         668 :     destroyPQExpBuffer(ruleprefix);
   19229         668 :     free(qtabname);
   19230             : }
   19231             : 
   19232             : /*
   19233             :  * getExtensionMembership --- obtain extension membership data
   19234             :  *
   19235             :  * We need to identify objects that are extension members as soon as they're
   19236             :  * loaded, so that we can correctly determine whether they need to be dumped.
   19237             :  * Generally speaking, extension member objects will get marked as *not* to
   19238             :  * be dumped, as they will be recreated by the single CREATE EXTENSION
   19239             :  * command.  However, in binary upgrade mode we still need to dump the members
   19240             :  * individually.
   19241             :  */
   19242             : void
   19243         470 : getExtensionMembership(Archive *fout, ExtensionInfo extinfo[],
   19244             :                        int numExtensions)
   19245             : {
   19246             :     PQExpBuffer query;
   19247             :     PGresult   *res;
   19248             :     int         ntups,
   19249             :                 i;
   19250             :     int         i_classid,
   19251             :                 i_objid,
   19252             :                 i_refobjid;
   19253             :     ExtensionInfo *ext;
   19254             : 
   19255             :     /* Nothing to do if no extensions */
   19256         470 :     if (numExtensions == 0)
   19257           0 :         return;
   19258             : 
   19259         470 :     query = createPQExpBuffer();
   19260             : 
   19261             :     /* refclassid constraint is redundant but may speed the search */
   19262         470 :     appendPQExpBufferStr(query, "SELECT "
   19263             :                          "classid, objid, refobjid "
   19264             :                          "FROM pg_depend "
   19265             :                          "WHERE refclassid = 'pg_extension'::regclass "
   19266             :                          "AND deptype = 'e' "
   19267             :                          "ORDER BY 3");
   19268             : 
   19269         470 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   19270             : 
   19271         470 :     ntups = PQntuples(res);
   19272             : 
   19273         470 :     i_classid = PQfnumber(res, "classid");
   19274         470 :     i_objid = PQfnumber(res, "objid");
   19275         470 :     i_refobjid = PQfnumber(res, "refobjid");
   19276             : 
   19277             :     /*
   19278             :      * Since we ordered the SELECT by referenced ID, we can expect that
   19279             :      * multiple entries for the same extension will appear together; this
   19280             :      * saves on searches.
   19281             :      */
   19282         470 :     ext = NULL;
   19283             : 
   19284        3550 :     for (i = 0; i < ntups; i++)
   19285             :     {
   19286             :         CatalogId   objId;
   19287             :         Oid         extId;
   19288             : 
   19289        3080 :         objId.tableoid = atooid(PQgetvalue(res, i, i_classid));
   19290        3080 :         objId.oid = atooid(PQgetvalue(res, i, i_objid));
   19291        3080 :         extId = atooid(PQgetvalue(res, i, i_refobjid));
   19292             : 
   19293        3080 :         if (ext == NULL ||
   19294        2610 :             ext->dobj.catId.oid != extId)
   19295         520 :             ext = findExtensionByOid(extId);
   19296             : 
   19297        3080 :         if (ext == NULL)
   19298             :         {
   19299             :             /* shouldn't happen */
   19300           0 :             pg_log_warning("could not find referenced extension %u", extId);
   19301           0 :             continue;
   19302             :         }
   19303             : 
   19304        3080 :         recordExtensionMembership(objId, ext);
   19305             :     }
   19306             : 
   19307         470 :     PQclear(res);
   19308             : 
   19309         470 :     destroyPQExpBuffer(query);
   19310             : }
   19311             : 
   19312             : /*
   19313             :  * processExtensionTables --- deal with extension configuration tables
   19314             :  *
   19315             :  * There are two parts to this process:
   19316             :  *
   19317             :  * 1. Identify and create dump records for extension configuration tables.
   19318             :  *
   19319             :  *    Extensions can mark tables as "configuration", which means that the user
   19320             :  *    is able and expected to modify those tables after the extension has been
   19321             :  *    loaded.  For these tables, we dump out only the data- the structure is
   19322             :  *    expected to be handled at CREATE EXTENSION time, including any indexes or
   19323             :  *    foreign keys, which brings us to-
   19324             :  *
   19325             :  * 2. Record FK dependencies between configuration tables.
   19326             :  *
   19327             :  *    Due to the FKs being created at CREATE EXTENSION time and therefore before
   19328             :  *    the data is loaded, we have to work out what the best order for reloading
   19329             :  *    the data is, to avoid FK violations when the tables are restored.  This is
   19330             :  *    not perfect- we can't handle circular dependencies and if any exist they
   19331             :  *    will cause an invalid dump to be produced (though at least all of the data
   19332             :  *    is included for a user to manually restore).  This is currently documented
   19333             :  *    but perhaps we can provide a better solution in the future.
   19334             :  */
   19335             : void
   19336         468 : processExtensionTables(Archive *fout, ExtensionInfo extinfo[],
   19337             :                        int numExtensions)
   19338             : {
   19339         468 :     DumpOptions *dopt = fout->dopt;
   19340             :     PQExpBuffer query;
   19341             :     PGresult   *res;
   19342             :     int         ntups,
   19343             :                 i;
   19344             :     int         i_conrelid,
   19345             :                 i_confrelid;
   19346             : 
   19347             :     /* Nothing to do if no extensions */
   19348         468 :     if (numExtensions == 0)
   19349           0 :         return;
   19350             : 
   19351             :     /*
   19352             :      * Identify extension configuration tables and create TableDataInfo
   19353             :      * objects for them, ensuring their data will be dumped even though the
   19354             :      * tables themselves won't be.
   19355             :      *
   19356             :      * Note that we create TableDataInfo objects even in schema-only mode, ie,
   19357             :      * user data in a configuration table is treated like schema data. This
   19358             :      * seems appropriate since system data in a config table would get
   19359             :      * reloaded by CREATE EXTENSION.  If the extension is not listed in the
   19360             :      * list of extensions to be included, none of its data is dumped.
   19361             :      */
   19362         986 :     for (i = 0; i < numExtensions; i++)
   19363             :     {
   19364         518 :         ExtensionInfo *curext = &(extinfo[i]);
   19365         518 :         char       *extconfig = curext->extconfig;
   19366         518 :         char       *extcondition = curext->extcondition;
   19367         518 :         char      **extconfigarray = NULL;
   19368         518 :         char      **extconditionarray = NULL;
   19369         518 :         int         nconfigitems = 0;
   19370         518 :         int         nconditionitems = 0;
   19371             : 
   19372             :         /*
   19373             :          * Check if this extension is listed as to include in the dump.  If
   19374             :          * not, any table data associated with it is discarded.
   19375             :          */
   19376         518 :         if (extension_include_oids.head != NULL &&
   19377          16 :             !simple_oid_list_member(&extension_include_oids,
   19378             :                                     curext->dobj.catId.oid))
   19379          12 :             continue;
   19380             : 
   19381             :         /*
   19382             :          * Check if this extension is listed as to exclude in the dump.  If
   19383             :          * yes, any table data associated with it is discarded.
   19384             :          */
   19385         518 :         if (extension_exclude_oids.head != NULL &&
   19386           8 :             simple_oid_list_member(&extension_exclude_oids,
   19387             :                                    curext->dobj.catId.oid))
   19388           4 :             continue;
   19389             : 
   19390         506 :         if (strlen(extconfig) != 0 || strlen(extcondition) != 0)
   19391             :         {
   19392             :             int         j;
   19393             : 
   19394          40 :             if (!parsePGArray(extconfig, &extconfigarray, &nconfigitems))
   19395           0 :                 pg_fatal("could not parse %s array", "extconfig");
   19396          40 :             if (!parsePGArray(extcondition, &extconditionarray, &nconditionitems))
   19397           0 :                 pg_fatal("could not parse %s array", "extcondition");
   19398          40 :             if (nconfigitems != nconditionitems)
   19399           0 :                 pg_fatal("mismatched number of configurations and conditions for extension");
   19400             : 
   19401         120 :             for (j = 0; j < nconfigitems; j++)
   19402             :             {
   19403             :                 TableInfo  *configtbl;
   19404          80 :                 Oid         configtbloid = atooid(extconfigarray[j]);
   19405          80 :                 bool        dumpobj =
   19406          80 :                     curext->dobj.dump & DUMP_COMPONENT_DEFINITION;
   19407             : 
   19408          80 :                 configtbl = findTableByOid(configtbloid);
   19409          80 :                 if (configtbl == NULL)
   19410           0 :                     continue;
   19411             : 
   19412             :                 /*
   19413             :                  * Tables of not-to-be-dumped extensions shouldn't be dumped
   19414             :                  * unless the table or its schema is explicitly included
   19415             :                  */
   19416          80 :                 if (!(curext->dobj.dump & DUMP_COMPONENT_DEFINITION))
   19417             :                 {
   19418             :                     /* check table explicitly requested */
   19419           4 :                     if (table_include_oids.head != NULL &&
   19420           0 :                         simple_oid_list_member(&table_include_oids,
   19421             :                                                configtbloid))
   19422           0 :                         dumpobj = true;
   19423             : 
   19424             :                     /* check table's schema explicitly requested */
   19425           4 :                     if (configtbl->dobj.namespace->dobj.dump &
   19426             :                         DUMP_COMPONENT_DATA)
   19427           4 :                         dumpobj = true;
   19428             :                 }
   19429             : 
   19430             :                 /* check table excluded by an exclusion switch */
   19431          88 :                 if (table_exclude_oids.head != NULL &&
   19432           8 :                     simple_oid_list_member(&table_exclude_oids,
   19433             :                                            configtbloid))
   19434           2 :                     dumpobj = false;
   19435             : 
   19436             :                 /* check schema excluded by an exclusion switch */
   19437          80 :                 if (simple_oid_list_member(&schema_exclude_oids,
   19438          80 :                                            configtbl->dobj.namespace->dobj.catId.oid))
   19439           0 :                     dumpobj = false;
   19440             : 
   19441          80 :                 if (dumpobj)
   19442             :                 {
   19443          78 :                     makeTableDataInfo(dopt, configtbl);
   19444          78 :                     if (configtbl->dataObj != NULL)
   19445             :                     {
   19446          78 :                         if (strlen(extconditionarray[j]) > 0)
   19447           0 :                             configtbl->dataObj->filtercond = pg_strdup(extconditionarray[j]);
   19448             :                     }
   19449             :                 }
   19450             :             }
   19451             :         }
   19452         506 :         if (extconfigarray)
   19453          40 :             free(extconfigarray);
   19454         506 :         if (extconditionarray)
   19455          40 :             free(extconditionarray);
   19456             :     }
   19457             : 
   19458             :     /*
   19459             :      * Now that all the TableDataInfo objects have been created for all the
   19460             :      * extensions, check their FK dependencies and register them to try and
   19461             :      * dump the data out in an order that they can be restored in.
   19462             :      *
   19463             :      * Note that this is not a problem for user tables as their FKs are
   19464             :      * recreated after the data has been loaded.
   19465             :      */
   19466             : 
   19467         468 :     query = createPQExpBuffer();
   19468             : 
   19469         468 :     printfPQExpBuffer(query,
   19470             :                       "SELECT conrelid, confrelid "
   19471             :                       "FROM pg_constraint "
   19472             :                       "JOIN pg_depend ON (objid = confrelid) "
   19473             :                       "WHERE contype = 'f' "
   19474             :                       "AND refclassid = 'pg_extension'::regclass "
   19475             :                       "AND classid = 'pg_class'::regclass;");
   19476             : 
   19477         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   19478         468 :     ntups = PQntuples(res);
   19479             : 
   19480         468 :     i_conrelid = PQfnumber(res, "conrelid");
   19481         468 :     i_confrelid = PQfnumber(res, "confrelid");
   19482             : 
   19483             :     /* Now get the dependencies and register them */
   19484         468 :     for (i = 0; i < ntups; i++)
   19485             :     {
   19486             :         Oid         conrelid,
   19487             :                     confrelid;
   19488             :         TableInfo  *reftable,
   19489             :                    *contable;
   19490             : 
   19491           0 :         conrelid = atooid(PQgetvalue(res, i, i_conrelid));
   19492           0 :         confrelid = atooid(PQgetvalue(res, i, i_confrelid));
   19493           0 :         contable = findTableByOid(conrelid);
   19494           0 :         reftable = findTableByOid(confrelid);
   19495             : 
   19496           0 :         if (reftable == NULL ||
   19497           0 :             reftable->dataObj == NULL ||
   19498           0 :             contable == NULL ||
   19499           0 :             contable->dataObj == NULL)
   19500           0 :             continue;
   19501             : 
   19502             :         /*
   19503             :          * Make referencing TABLE_DATA object depend on the referenced table's
   19504             :          * TABLE_DATA object.
   19505             :          */
   19506           0 :         addObjectDependency(&contable->dataObj->dobj,
   19507           0 :                             reftable->dataObj->dobj.dumpId);
   19508             :     }
   19509         468 :     PQclear(res);
   19510         468 :     destroyPQExpBuffer(query);
   19511             : }
   19512             : 
   19513             : /*
   19514             :  * getDependencies --- obtain available dependency data
   19515             :  */
   19516             : static void
   19517         468 : getDependencies(Archive *fout)
   19518             : {
   19519             :     PQExpBuffer query;
   19520             :     PGresult   *res;
   19521             :     int         ntups,
   19522             :                 i;
   19523             :     int         i_classid,
   19524             :                 i_objid,
   19525             :                 i_refclassid,
   19526             :                 i_refobjid,
   19527             :                 i_deptype;
   19528             :     DumpableObject *dobj,
   19529             :                *refdobj;
   19530             : 
   19531         468 :     pg_log_info("reading dependency data");
   19532             : 
   19533         468 :     query = createPQExpBuffer();
   19534             : 
   19535             :     /*
   19536             :      * Messy query to collect the dependency data we need.  Note that we
   19537             :      * ignore the sub-object column, so that dependencies of or on a column
   19538             :      * look the same as dependencies of or on a whole table.
   19539             :      *
   19540             :      * PIN dependencies aren't interesting, and EXTENSION dependencies were
   19541             :      * already processed by getExtensionMembership.
   19542             :      */
   19543         468 :     appendPQExpBufferStr(query, "SELECT "
   19544             :                          "classid, objid, refclassid, refobjid, deptype "
   19545             :                          "FROM pg_depend "
   19546             :                          "WHERE deptype != 'p' AND deptype != 'e'\n");
   19547             : 
   19548             :     /*
   19549             :      * Since we don't treat pg_amop entries as separate DumpableObjects, we
   19550             :      * have to translate their dependencies into dependencies of their parent
   19551             :      * opfamily.  Ignore internal dependencies though, as those will point to
   19552             :      * their parent opclass, which we needn't consider here (and if we did,
   19553             :      * it'd just result in circular dependencies).  Also, "loose" opfamily
   19554             :      * entries will have dependencies on their parent opfamily, which we
   19555             :      * should drop since they'd likewise become useless self-dependencies.
   19556             :      * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.)
   19557             :      */
   19558         468 :     appendPQExpBufferStr(query, "UNION ALL\n"
   19559             :                          "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype "
   19560             :                          "FROM pg_depend d, pg_amop o "
   19561             :                          "WHERE deptype NOT IN ('p', 'e', 'i') AND "
   19562             :                          "classid = 'pg_amop'::regclass AND objid = o.oid "
   19563             :                          "AND NOT (refclassid = 'pg_opfamily'::regclass AND amopfamily = refobjid)\n");
   19564             : 
   19565             :     /* Likewise for pg_amproc entries */
   19566         468 :     appendPQExpBufferStr(query, "UNION ALL\n"
   19567             :                          "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype "
   19568             :                          "FROM pg_depend d, pg_amproc p "
   19569             :                          "WHERE deptype NOT IN ('p', 'e', 'i') AND "
   19570             :                          "classid = 'pg_amproc'::regclass AND objid = p.oid "
   19571             :                          "AND NOT (refclassid = 'pg_opfamily'::regclass AND amprocfamily = refobjid)\n");
   19572             : 
   19573             :     /* Sort the output for efficiency below */
   19574         468 :     appendPQExpBufferStr(query, "ORDER BY 1,2");
   19575             : 
   19576         468 :     res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK);
   19577             : 
   19578         468 :     ntups = PQntuples(res);
   19579             : 
   19580         468 :     i_classid = PQfnumber(res, "classid");
   19581         468 :     i_objid = PQfnumber(res, "objid");
   19582         468 :     i_refclassid = PQfnumber(res, "refclassid");
   19583         468 :     i_refobjid = PQfnumber(res, "refobjid");
   19584         468 :     i_deptype = PQfnumber(res, "deptype");
   19585             : 
   19586             :     /*
   19587             :      * Since we ordered the SELECT by referencing ID, we can expect that
   19588             :      * multiple entries for the same object will appear together; this saves
   19589             :      * on searches.
   19590             :      */
   19591         468 :     dobj = NULL;
   19592             : 
   19593     1007324 :     for (i = 0; i < ntups; i++)
   19594             :     {
   19595             :         CatalogId   objId;
   19596             :         CatalogId   refobjId;
   19597             :         char        deptype;
   19598             : 
   19599     1006856 :         objId.tableoid = atooid(PQgetvalue(res, i, i_classid));
   19600     1006856 :         objId.oid = atooid(PQgetvalue(res, i, i_objid));
   19601     1006856 :         refobjId.tableoid = atooid(PQgetvalue(res, i, i_refclassid));
   19602     1006856 :         refobjId.oid = atooid(PQgetvalue(res, i, i_refobjid));
   19603     1006856 :         deptype = *(PQgetvalue(res, i, i_deptype));
   19604             : 
   19605     1006856 :         if (dobj == NULL ||
   19606      945910 :             dobj->catId.tableoid != objId.tableoid ||
   19607      940872 :             dobj->catId.oid != objId.oid)
   19608      439914 :             dobj = findObjectByCatalogId(objId);
   19609             : 
   19610             :         /*
   19611             :          * Failure to find objects mentioned in pg_depend is not unexpected,
   19612             :          * since for example we don't collect info about TOAST tables.
   19613             :          */
   19614     1006856 :         if (dobj == NULL)
   19615             :         {
   19616             : #ifdef NOT_USED
   19617             :             pg_log_warning("no referencing object %u %u",
   19618             :                            objId.tableoid, objId.oid);
   19619             : #endif
   19620       62702 :             continue;
   19621             :         }
   19622             : 
   19623      946378 :         refdobj = findObjectByCatalogId(refobjId);
   19624             : 
   19625      946378 :         if (refdobj == NULL)
   19626             :         {
   19627             : #ifdef NOT_USED
   19628             :             pg_log_warning("no referenced object %u %u",
   19629             :                            refobjId.tableoid, refobjId.oid);
   19630             : #endif
   19631        2224 :             continue;
   19632             :         }
   19633             : 
   19634             :         /*
   19635             :          * For 'x' dependencies, mark the object for later; we still add the
   19636             :          * normal dependency, for possible ordering purposes.  Currently
   19637             :          * pg_dump_sort.c knows to put extensions ahead of all object types
   19638             :          * that could possibly depend on them, but this is safer.
   19639             :          */
   19640      944154 :         if (deptype == 'x')
   19641          88 :             dobj->depends_on_ext = true;
   19642             : 
   19643             :         /*
   19644             :          * Ordinarily, table rowtypes have implicit dependencies on their
   19645             :          * tables.  However, for a composite type the implicit dependency goes
   19646             :          * the other way in pg_depend; which is the right thing for DROP but
   19647             :          * it doesn't produce the dependency ordering we need. So in that one
   19648             :          * case, we reverse the direction of the dependency.
   19649             :          */
   19650      944154 :         if (deptype == 'i' &&
   19651      264364 :             dobj->objType == DO_TABLE &&
   19652        3248 :             refdobj->objType == DO_TYPE)
   19653         468 :             addObjectDependency(refdobj, dobj->dumpId);
   19654             :         else
   19655             :             /* normal case */
   19656      943686 :             addObjectDependency(dobj, refdobj->dumpId);
   19657             :     }
   19658             : 
   19659         468 :     PQclear(res);
   19660             : 
   19661         468 :     destroyPQExpBuffer(query);
   19662         468 : }
   19663             : 
   19664             : 
   19665             : /*
   19666             :  * createBoundaryObjects - create dummy DumpableObjects to represent
   19667             :  * dump section boundaries.
   19668             :  */
   19669             : static DumpableObject *
   19670         468 : createBoundaryObjects(void)
   19671             : {
   19672             :     DumpableObject *dobjs;
   19673             : 
   19674         468 :     dobjs = (DumpableObject *) pg_malloc(2 * sizeof(DumpableObject));
   19675             : 
   19676         468 :     dobjs[0].objType = DO_PRE_DATA_BOUNDARY;
   19677         468 :     dobjs[0].catId = nilCatalogId;
   19678         468 :     AssignDumpId(dobjs + 0);
   19679         468 :     dobjs[0].name = pg_strdup("PRE-DATA BOUNDARY");
   19680             : 
   19681         468 :     dobjs[1].objType = DO_POST_DATA_BOUNDARY;
   19682         468 :     dobjs[1].catId = nilCatalogId;
   19683         468 :     AssignDumpId(dobjs + 1);
   19684         468 :     dobjs[1].name = pg_strdup("POST-DATA BOUNDARY");
   19685             : 
   19686         468 :     return dobjs;
   19687             : }
   19688             : 
   19689             : /*
   19690             :  * addBoundaryDependencies - add dependencies as needed to enforce the dump
   19691             :  * section boundaries.
   19692             :  */
   19693             : static void
   19694         468 : addBoundaryDependencies(DumpableObject **dobjs, int numObjs,
   19695             :                         DumpableObject *boundaryObjs)
   19696             : {
   19697         468 :     DumpableObject *preDataBound = boundaryObjs + 0;
   19698         468 :     DumpableObject *postDataBound = boundaryObjs + 1;
   19699             :     int         i;
   19700             : 
   19701     1731722 :     for (i = 0; i < numObjs; i++)
   19702             :     {
   19703     1731254 :         DumpableObject *dobj = dobjs[i];
   19704             : 
   19705             :         /*
   19706             :          * The classification of object types here must match the SECTION_xxx
   19707             :          * values assigned during subsequent ArchiveEntry calls!
   19708             :          */
   19709     1731254 :         switch (dobj->objType)
   19710             :         {
   19711     1605998 :             case DO_NAMESPACE:
   19712             :             case DO_EXTENSION:
   19713             :             case DO_TYPE:
   19714             :             case DO_SHELL_TYPE:
   19715             :             case DO_FUNC:
   19716             :             case DO_AGG:
   19717             :             case DO_OPERATOR:
   19718             :             case DO_ACCESS_METHOD:
   19719             :             case DO_OPCLASS:
   19720             :             case DO_OPFAMILY:
   19721             :             case DO_COLLATION:
   19722             :             case DO_CONVERSION:
   19723             :             case DO_TABLE:
   19724             :             case DO_TABLE_ATTACH:
   19725             :             case DO_ATTRDEF:
   19726             :             case DO_PROCLANG:
   19727             :             case DO_CAST:
   19728             :             case DO_DUMMY_TYPE:
   19729             :             case DO_TSPARSER:
   19730             :             case DO_TSDICT:
   19731             :             case DO_TSTEMPLATE:
   19732             :             case DO_TSCONFIG:
   19733             :             case DO_FDW:
   19734             :             case DO_FOREIGN_SERVER:
   19735             :             case DO_TRANSFORM:
   19736             :                 /* Pre-data objects: must come before the pre-data boundary */
   19737     1605998 :                 addObjectDependency(preDataBound, dobj->dumpId);
   19738     1605998 :                 break;
   19739       13470 :             case DO_TABLE_DATA:
   19740             :             case DO_SEQUENCE_SET:
   19741             :             case DO_LARGE_OBJECT:
   19742             :             case DO_LARGE_OBJECT_DATA:
   19743             :                 /* Data objects: must come between the boundaries */
   19744       13470 :                 addObjectDependency(dobj, preDataBound->dumpId);
   19745       13470 :                 addObjectDependency(postDataBound, dobj->dumpId);
   19746       13470 :                 break;
   19747       14092 :             case DO_INDEX:
   19748             :             case DO_INDEX_ATTACH:
   19749             :             case DO_STATSEXT:
   19750             :             case DO_REFRESH_MATVIEW:
   19751             :             case DO_TRIGGER:
   19752             :             case DO_EVENT_TRIGGER:
   19753             :             case DO_DEFAULT_ACL:
   19754             :             case DO_POLICY:
   19755             :             case DO_PUBLICATION:
   19756             :             case DO_PUBLICATION_REL:
   19757             :             case DO_PUBLICATION_TABLE_IN_SCHEMA:
   19758             :             case DO_SUBSCRIPTION:
   19759             :             case DO_SUBSCRIPTION_REL:
   19760             :                 /* Post-data objects: must come after the post-data boundary */
   19761       14092 :                 addObjectDependency(dobj, postDataBound->dumpId);
   19762       14092 :                 break;
   19763       71814 :             case DO_RULE:
   19764             :                 /* Rules are post-data, but only if dumped separately */
   19765       71814 :                 if (((RuleInfo *) dobj)->separate)
   19766        1716 :                     addObjectDependency(dobj, postDataBound->dumpId);
   19767       71814 :                 break;
   19768        6426 :             case DO_CONSTRAINT:
   19769             :             case DO_FK_CONSTRAINT:
   19770             :                 /* Constraints are post-data, but only if dumped separately */
   19771        6426 :                 if (((ConstraintInfo *) dobj)->separate)
   19772        4696 :                     addObjectDependency(dobj, postDataBound->dumpId);
   19773        6426 :                 break;
   19774         468 :             case DO_PRE_DATA_BOUNDARY:
   19775             :                 /* nothing to do */
   19776         468 :                 break;
   19777         468 :             case DO_POST_DATA_BOUNDARY:
   19778             :                 /* must come after the pre-data boundary */
   19779         468 :                 addObjectDependency(dobj, preDataBound->dumpId);
   19780         468 :                 break;
   19781       18518 :             case DO_REL_STATS:
   19782             :                 /* stats section varies by parent object type, DATA or POST */
   19783       18518 :                 if (((RelStatsInfo *) dobj)->section == SECTION_DATA)
   19784             :                 {
   19785       12138 :                     addObjectDependency(dobj, preDataBound->dumpId);
   19786       12138 :                     addObjectDependency(postDataBound, dobj->dumpId);
   19787             :                 }
   19788             :                 else
   19789        6380 :                     addObjectDependency(dobj, postDataBound->dumpId);
   19790       18518 :                 break;
   19791             :         }
   19792     1731254 :     }
   19793         468 : }
   19794             : 
   19795             : 
   19796             : /*
   19797             :  * BuildArchiveDependencies - create dependency data for archive TOC entries
   19798             :  *
   19799             :  * The raw dependency data obtained by getDependencies() is not terribly
   19800             :  * useful in an archive dump, because in many cases there are dependency
   19801             :  * chains linking through objects that don't appear explicitly in the dump.
   19802             :  * For example, a view will depend on its _RETURN rule while the _RETURN rule
   19803             :  * will depend on other objects --- but the rule will not appear as a separate
   19804             :  * object in the dump.  We need to adjust the view's dependencies to include
   19805             :  * whatever the rule depends on that is included in the dump.
   19806             :  *
   19807             :  * Just to make things more complicated, there are also "special" dependencies
   19808             :  * such as the dependency of a TABLE DATA item on its TABLE, which we must
   19809             :  * not rearrange because pg_restore knows that TABLE DATA only depends on
   19810             :  * its table.  In these cases we must leave the dependencies strictly as-is
   19811             :  * even if they refer to not-to-be-dumped objects.
   19812             :  *
   19813             :  * To handle this, the convention is that "special" dependencies are created
   19814             :  * during ArchiveEntry calls, and an archive TOC item that has any such
   19815             :  * entries will not be touched here.  Otherwise, we recursively search the
   19816             :  * DumpableObject data structures to build the correct dependencies for each
   19817             :  * archive TOC item.
   19818             :  */
   19819             : static void
   19820         206 : BuildArchiveDependencies(Archive *fout)
   19821             : {
   19822         206 :     ArchiveHandle *AH = (ArchiveHandle *) fout;
   19823             :     TocEntry   *te;
   19824             : 
   19825             :     /* Scan all TOC entries in the archive */
   19826       22516 :     for (te = AH->toc->next; te != AH->toc; te = te->next)
   19827             :     {
   19828             :         DumpableObject *dobj;
   19829             :         DumpId     *dependencies;
   19830             :         int         nDeps;
   19831             :         int         allocDeps;
   19832             : 
   19833             :         /* No need to process entries that will not be dumped */
   19834       22310 :         if (te->reqs == 0)
   19835       11134 :             continue;
   19836             :         /* Ignore entries that already have "special" dependencies */
   19837       22304 :         if (te->nDeps > 0)
   19838        9882 :             continue;
   19839             :         /* Otherwise, look up the item's original DumpableObject, if any */
   19840       12422 :         dobj = findObjectByDumpId(te->dumpId);
   19841       12422 :         if (dobj == NULL)
   19842         978 :             continue;
   19843             :         /* No work if it has no dependencies */
   19844       11444 :         if (dobj->nDeps <= 0)
   19845         268 :             continue;
   19846             :         /* Set up work array */
   19847       11176 :         allocDeps = 64;
   19848       11176 :         dependencies = (DumpId *) pg_malloc(allocDeps * sizeof(DumpId));
   19849       11176 :         nDeps = 0;
   19850             :         /* Recursively find all dumpable dependencies */
   19851       11176 :         findDumpableDependencies(AH, dobj,
   19852             :                                  &dependencies, &nDeps, &allocDeps);
   19853             :         /* And save 'em ... */
   19854       11176 :         if (nDeps > 0)
   19855             :         {
   19856        7904 :             dependencies = (DumpId *) pg_realloc(dependencies,
   19857             :                                                  nDeps * sizeof(DumpId));
   19858        7904 :             te->dependencies = dependencies;
   19859        7904 :             te->nDeps = nDeps;
   19860             :         }
   19861             :         else
   19862        3272 :             free(dependencies);
   19863             :     }
   19864         206 : }
   19865             : 
   19866             : /* Recursive search subroutine for BuildArchiveDependencies */
   19867             : static void
   19868       26536 : findDumpableDependencies(ArchiveHandle *AH, const DumpableObject *dobj,
   19869             :                          DumpId **dependencies, int *nDeps, int *allocDeps)
   19870             : {
   19871             :     int         i;
   19872             : 
   19873             :     /*
   19874             :      * Ignore section boundary objects: if we search through them, we'll
   19875             :      * report lots of bogus dependencies.
   19876             :      */
   19877       26536 :     if (dobj->objType == DO_PRE_DATA_BOUNDARY ||
   19878       26496 :         dobj->objType == DO_POST_DATA_BOUNDARY)
   19879        4296 :         return;
   19880             : 
   19881       54294 :     for (i = 0; i < dobj->nDeps; i++)
   19882             :     {
   19883       32054 :         DumpId      depid = dobj->dependencies[i];
   19884             : 
   19885       32054 :         if (TocIDRequired(AH, depid) != 0)
   19886             :         {
   19887             :             /* Object will be dumped, so just reference it as a dependency */
   19888       16694 :             if (*nDeps >= *allocDeps)
   19889             :             {
   19890           0 :                 *allocDeps *= 2;
   19891           0 :                 *dependencies = (DumpId *) pg_realloc(*dependencies,
   19892           0 :                                                       *allocDeps * sizeof(DumpId));
   19893             :             }
   19894       16694 :             (*dependencies)[*nDeps] = depid;
   19895       16694 :             (*nDeps)++;
   19896             :         }
   19897             :         else
   19898             :         {
   19899             :             /*
   19900             :              * Object will not be dumped, so recursively consider its deps. We
   19901             :              * rely on the assumption that sortDumpableObjects already broke
   19902             :              * any dependency loops, else we might recurse infinitely.
   19903             :              */
   19904       15360 :             DumpableObject *otherdobj = findObjectByDumpId(depid);
   19905             : 
   19906       15360 :             if (otherdobj)
   19907       15360 :                 findDumpableDependencies(AH, otherdobj,
   19908             :                                          dependencies, nDeps, allocDeps);
   19909             :         }
   19910             :     }
   19911             : }
   19912             : 
   19913             : 
   19914             : /*
   19915             :  * getFormattedTypeName - retrieve a nicely-formatted type name for the
   19916             :  * given type OID.
   19917             :  *
   19918             :  * This does not guarantee to schema-qualify the output, so it should not
   19919             :  * be used to create the target object name for CREATE or ALTER commands.
   19920             :  *
   19921             :  * Note that the result is cached and must not be freed by the caller.
   19922             :  */
   19923             : static const char *
   19924        6916 : getFormattedTypeName(Archive *fout, Oid oid, OidOptions opts)
   19925             : {
   19926             :     TypeInfo   *typeInfo;
   19927             :     char       *result;
   19928             :     PQExpBuffer query;
   19929             :     PGresult   *res;
   19930             : 
   19931        6916 :     if (oid == 0)
   19932             :     {
   19933           0 :         if ((opts & zeroAsStar) != 0)
   19934           0 :             return "*";
   19935           0 :         else if ((opts & zeroAsNone) != 0)
   19936           0 :             return "NONE";
   19937             :     }
   19938             : 
   19939             :     /* see if we have the result cached in the type's TypeInfo record */
   19940        6916 :     typeInfo = findTypeByOid(oid);
   19941        6916 :     if (typeInfo && typeInfo->ftypname)
   19942        5680 :         return typeInfo->ftypname;
   19943             : 
   19944        1236 :     query = createPQExpBuffer();
   19945        1236 :     appendPQExpBuffer(query, "SELECT pg_catalog.format_type('%u'::pg_catalog.oid, NULL)",
   19946             :                       oid);
   19947             : 
   19948        1236 :     res = ExecuteSqlQueryForSingleRow(fout, query->data);
   19949             : 
   19950             :     /* result of format_type is already quoted */
   19951        1236 :     result = pg_strdup(PQgetvalue(res, 0, 0));
   19952             : 
   19953        1236 :     PQclear(res);
   19954        1236 :     destroyPQExpBuffer(query);
   19955             : 
   19956             :     /*
   19957             :      * Cache the result for re-use in later requests, if possible.  If we
   19958             :      * don't have a TypeInfo for the type, the string will be leaked once the
   19959             :      * caller is done with it ... but that case really should not happen, so
   19960             :      * leaking if it does seems acceptable.
   19961             :      */
   19962        1236 :     if (typeInfo)
   19963        1236 :         typeInfo->ftypname = result;
   19964             : 
   19965        1236 :     return result;
   19966             : }
   19967             : 
   19968             : /*
   19969             :  * Return a column list clause for the given relation.
   19970             :  *
   19971             :  * Special case: if there are no undropped columns in the relation, return
   19972             :  * "", not an invalid "()" column list.
   19973             :  */
   19974             : static const char *
   19975       23576 : fmtCopyColumnList(const TableInfo *ti, PQExpBuffer buffer)
   19976             : {
   19977       23576 :     int         numatts = ti->numatts;
   19978       23576 :     char      **attnames = ti->attnames;
   19979       23576 :     bool       *attisdropped = ti->attisdropped;
   19980       23576 :     char       *attgenerated = ti->attgenerated;
   19981             :     bool        needComma;
   19982             :     int         i;
   19983             : 
   19984       23576 :     appendPQExpBufferChar(buffer, '(');
   19985       23576 :     needComma = false;
   19986      119240 :     for (i = 0; i < numatts; i++)
   19987             :     {
   19988       95664 :         if (attisdropped[i])
   19989        1744 :             continue;
   19990       93920 :         if (attgenerated[i])
   19991        3188 :             continue;
   19992       90732 :         if (needComma)
   19993       67688 :             appendPQExpBufferStr(buffer, ", ");
   19994       90732 :         appendPQExpBufferStr(buffer, fmtId(attnames[i]));
   19995       90732 :         needComma = true;
   19996             :     }
   19997             : 
   19998       23576 :     if (!needComma)
   19999         532 :         return "";                /* no undropped columns */
   20000             : 
   20001       23044 :     appendPQExpBufferChar(buffer, ')');
   20002       23044 :     return buffer->data;
   20003             : }
   20004             : 
   20005             : /*
   20006             :  * Check if a reloptions array is nonempty.
   20007             :  */
   20008             : static bool
   20009       36962 : nonemptyReloptions(const char *reloptions)
   20010             : {
   20011             :     /* Don't want to print it if it's just "{}" */
   20012       36962 :     return (reloptions != NULL && strlen(reloptions) > 2);
   20013             : }
   20014             : 
   20015             : /*
   20016             :  * Format a reloptions array and append it to the given buffer.
   20017             :  *
   20018             :  * "prefix" is prepended to the option names; typically it's "" or "toast.".
   20019             :  */
   20020             : static void
   20021         594 : appendReloptionsArrayAH(PQExpBuffer buffer, const char *reloptions,
   20022             :                         const char *prefix, Archive *fout)
   20023             : {
   20024             :     bool        res;
   20025             : 
   20026         594 :     res = appendReloptionsArray(buffer, reloptions, prefix, fout->encoding,
   20027         594 :                                 fout->std_strings);
   20028         594 :     if (!res)
   20029           0 :         pg_log_warning("could not parse %s array", "reloptions");
   20030         594 : }
   20031             : 
   20032             : /*
   20033             :  * read_dump_filters - retrieve object identifier patterns from file
   20034             :  *
   20035             :  * Parse the specified filter file for include and exclude patterns, and add
   20036             :  * them to the relevant lists.  If the filename is "-" then filters will be
   20037             :  * read from STDIN rather than a file.
   20038             :  */
   20039             : static void
   20040          52 : read_dump_filters(const char *filename, DumpOptions *dopt)
   20041             : {
   20042             :     FilterStateData fstate;
   20043             :     char       *objname;
   20044             :     FilterCommandType comtype;
   20045             :     FilterObjectType objtype;
   20046             : 
   20047          52 :     filter_init(&fstate, filename, exit_nicely);
   20048             : 
   20049         116 :     while (filter_read_item(&fstate, &objname, &comtype, &objtype))
   20050             :     {
   20051          66 :         if (comtype == FILTER_COMMAND_TYPE_INCLUDE)
   20052             :         {
   20053          34 :             switch (objtype)
   20054             :             {
   20055           0 :                 case FILTER_OBJECT_TYPE_NONE:
   20056           0 :                     break;
   20057           0 :                 case FILTER_OBJECT_TYPE_DATABASE:
   20058             :                 case FILTER_OBJECT_TYPE_FUNCTION:
   20059             :                 case FILTER_OBJECT_TYPE_INDEX:
   20060             :                 case FILTER_OBJECT_TYPE_TABLE_DATA:
   20061             :                 case FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN:
   20062             :                 case FILTER_OBJECT_TYPE_TRIGGER:
   20063           0 :                     pg_log_filter_error(&fstate, _("%s filter for \"%s\" is not allowed"),
   20064             :                                         "include",
   20065             :                                         filter_object_type_name(objtype));
   20066           0 :                     exit_nicely(1);
   20067             :                     break;      /* unreachable */
   20068             : 
   20069           2 :                 case FILTER_OBJECT_TYPE_EXTENSION:
   20070           2 :                     simple_string_list_append(&extension_include_patterns, objname);
   20071           2 :                     break;
   20072           2 :                 case FILTER_OBJECT_TYPE_FOREIGN_DATA:
   20073           2 :                     simple_string_list_append(&foreign_servers_include_patterns, objname);
   20074           2 :                     break;
   20075           2 :                 case FILTER_OBJECT_TYPE_SCHEMA:
   20076           2 :                     simple_string_list_append(&schema_include_patterns, objname);
   20077           2 :                     dopt->include_everything = false;
   20078           2 :                     break;
   20079          26 :                 case FILTER_OBJECT_TYPE_TABLE:
   20080          26 :                     simple_string_list_append(&table_include_patterns, objname);
   20081          26 :                     dopt->include_everything = false;
   20082          26 :                     break;
   20083           2 :                 case FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN:
   20084           2 :                     simple_string_list_append(&table_include_patterns_and_children,
   20085             :                                               objname);
   20086           2 :                     dopt->include_everything = false;
   20087           2 :                     break;
   20088             :             }
   20089          34 :         }
   20090          32 :         else if (comtype == FILTER_COMMAND_TYPE_EXCLUDE)
   20091             :         {
   20092          18 :             switch (objtype)
   20093             :             {
   20094           0 :                 case FILTER_OBJECT_TYPE_NONE:
   20095           0 :                     break;
   20096           2 :                 case FILTER_OBJECT_TYPE_DATABASE:
   20097             :                 case FILTER_OBJECT_TYPE_FUNCTION:
   20098             :                 case FILTER_OBJECT_TYPE_INDEX:
   20099             :                 case FILTER_OBJECT_TYPE_TRIGGER:
   20100             :                 case FILTER_OBJECT_TYPE_FOREIGN_DATA:
   20101           2 :                     pg_log_filter_error(&fstate, _("%s filter for \"%s\" is not allowed"),
   20102             :                                         "exclude",
   20103             :                                         filter_object_type_name(objtype));
   20104           2 :                     exit_nicely(1);
   20105             :                     break;
   20106             : 
   20107           2 :                 case FILTER_OBJECT_TYPE_EXTENSION:
   20108           2 :                     simple_string_list_append(&extension_exclude_patterns, objname);
   20109           2 :                     break;
   20110           2 :                 case FILTER_OBJECT_TYPE_TABLE_DATA:
   20111           2 :                     simple_string_list_append(&tabledata_exclude_patterns,
   20112             :                                               objname);
   20113           2 :                     break;
   20114           2 :                 case FILTER_OBJECT_TYPE_TABLE_DATA_AND_CHILDREN:
   20115           2 :                     simple_string_list_append(&tabledata_exclude_patterns_and_children,
   20116             :                                               objname);
   20117           2 :                     break;
   20118           4 :                 case FILTER_OBJECT_TYPE_SCHEMA:
   20119           4 :                     simple_string_list_append(&schema_exclude_patterns, objname);
   20120           4 :                     break;
   20121           4 :                 case FILTER_OBJECT_TYPE_TABLE:
   20122           4 :                     simple_string_list_append(&table_exclude_patterns, objname);
   20123           4 :                     break;
   20124           2 :                 case FILTER_OBJECT_TYPE_TABLE_AND_CHILDREN:
   20125           2 :                     simple_string_list_append(&table_exclude_patterns_and_children,
   20126             :                                               objname);
   20127           2 :                     break;
   20128             :             }
   20129          16 :         }
   20130             :         else
   20131             :         {
   20132             :             Assert(comtype == FILTER_COMMAND_TYPE_NONE);
   20133             :             Assert(objtype == FILTER_OBJECT_TYPE_NONE);
   20134             :         }
   20135             : 
   20136          64 :         if (objname)
   20137          50 :             free(objname);
   20138             :     }
   20139             : 
   20140          44 :     filter_free(&fstate);
   20141          44 : }

Generated by: LCOV version 1.14