static const CatalogId nilCatalogId = {0, 0};
+/*
+ * Macro for producing quoted, schema-qualified name of a dumpable object.
+ * Note implicit dependence on "fout"; we should get rid of that argument.
+ */
+#define fmtQualifiedDumpable(obj) \
+ fmtQualifiedId(fout->remoteVersion, \
+ (obj)->dobj.namespace->dobj.name, \
+ (obj)->dobj.name)
+
static void help(const char *progname);
static void setup_connection(Archive *AH,
const char *dumpencoding, const char *dumpsnapshot,
static void dumpTableData(Archive *fout, TableDataInfo *tdinfo);
static void refreshMatViewData(Archive *fout, TableDataInfo *tdinfo);
static void guessConstraintInheritance(TableInfo *tblinfo, int numTables);
-static void dumpComment(Archive *fout, const char *target,
+static void dumpComment(Archive *fout, const char *type, const char *name,
const char *namespace, const char *owner,
CatalogId catalogId, int subid, DumpId dumpId);
static int findComments(Archive *fout, Oid classoid, Oid objoid,
CommentItem **items);
static int collectComments(Archive *fout, CommentItem **items);
-static void dumpSecLabel(Archive *fout, const char *target,
+static void dumpSecLabel(Archive *fout, const char *type, const char *name,
const char *namespace, const char *owner,
CatalogId catalogId, int subid, DumpId dumpId);
static int findSecLabels(Archive *fout, Oid classoid, Oid objoid,
static void dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
const char *type, const char *name, const char *subname,
- const char *tag, const char *nspname, const char *owner,
+ const char *nspname, const char *owner,
const char *acls, const char *racls,
const char *initacls, const char *initracls);
FuncInfo *finfo, bool honor_quotes);
static char *convertRegProcReference(Archive *fout,
const char *proc);
-static char *convertOperatorReference(Archive *fout, const char *opr);
+static char *getFormattedOperatorName(Archive *fout, const char *oproid);
static char *convertTSFunction(Archive *fout, Oid funcOid);
static Oid findLastBuiltinOid_V71(Archive *fout, const char *);
-static void selectSourceSchema(Archive *fout, const char *schemaName);
static char *getFormattedTypeName(Archive *fout, Oid oid, OidOptions opts);
static void getBlobs(Archive *fout);
static void dumpBlob(Archive *fout, BlobInfo *binfo);
const char *dbname, Oid dboid);
static void dumpEncoding(Archive *AH);
static void dumpStdStrings(Archive *AH);
+static void dumpSearchPath(Archive *AH);
static void binary_upgrade_set_type_oids_by_type_oid(Archive *fout,
PQExpBuffer upgrade_buffer,
Oid pg_type_oid,
Oid pg_class_oid, bool is_index);
static void binary_upgrade_extension_member(PQExpBuffer upgrade_buffer,
DumpableObject *dobj,
- const char *objlabel);
+ const char *objtype,
+ const char *objname,
+ const char *objnamespace);
static const char *getAttrName(int attrnum, TableInfo *tblInfo);
static const char *fmtCopyColumnList(const TableInfo *ti, PQExpBuffer buffer);
static bool nonemptyReloptions(const char *reloptions);
* order.
*/
- /* First the special ENCODING and STDSTRINGS entries. */
+ /* First the special ENCODING, STDSTRINGS, and SEARCHPATH entries. */
dumpEncoding(fout);
dumpStdStrings(fout);
+ dumpSearchPath(fout);
/* The database items are always next, unless we don't want them at all */
if (dopt.outputCreateDB)
write_msg(NULL, "dumping contents of table \"%s.%s\"\n",
tbinfo->dobj.namespace->dobj.name, classname);
- /*
- * Make sure we are in proper schema. We will qualify the table name
- * below anyway (in case its name conflicts with a pg_catalog table); but
- * this ensures reproducible results in case the table contains regproc,
- * regclass, etc columns.
- */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
/*
* Specify the column list explicitly so that we have no possibility of
* retrieving data in the wrong column order. (The default column
if (oids && hasoids)
{
appendPQExpBuffer(q, "COPY %s %s WITH OIDS TO stdout;",
- fmtQualifiedId(fout->remoteVersion,
- tbinfo->dobj.namespace->dobj.name,
- classname),
+ fmtQualifiedDumpable(tbinfo),
column_list);
}
else if (tdinfo->filtercond)
else
appendPQExpBufferStr(q, "* ");
appendPQExpBuffer(q, "FROM %s %s) TO stdout;",
- fmtQualifiedId(fout->remoteVersion,
- tbinfo->dobj.namespace->dobj.name,
- classname),
+ fmtQualifiedDumpable(tbinfo),
tdinfo->filtercond);
}
else
{
appendPQExpBuffer(q, "COPY %s %s TO stdout;",
- fmtQualifiedId(fout->remoteVersion,
- tbinfo->dobj.namespace->dobj.name,
- classname),
+ fmtQualifiedDumpable(tbinfo),
column_list);
}
res = ExecuteSqlQuery(fout, q->data, PGRES_COPY_OUT);
{
TableDataInfo *tdinfo = (TableDataInfo *) dcontext;
TableInfo *tbinfo = tdinfo->tdtable;
- const char *classname = tbinfo->dobj.name;
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer insertStmt = NULL;
int nfields;
int field;
- /*
- * Make sure we are in proper schema. We will qualify the table name
- * below anyway (in case its name conflicts with a pg_catalog table); but
- * this ensures reproducible results in case the table contains regproc,
- * regclass, etc columns.
- */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
appendPQExpBuffer(q, "DECLARE _pg_dump_cursor CURSOR FOR "
"SELECT * FROM ONLY %s",
- fmtQualifiedId(fout->remoteVersion,
- tbinfo->dobj.namespace->dobj.name,
- classname));
+ fmtQualifiedDumpable(tbinfo));
if (tdinfo->filtercond)
appendPQExpBuffer(q, " %s", tdinfo->filtercond);
*/
if (insertStmt == NULL)
{
+ TableInfo *targettab;
+
insertStmt = createPQExpBuffer();
/*
* through the root table.
*/
if (dopt->load_via_partition_root && tbinfo->ispartition)
- {
- TableInfo *parentTbinfo;
-
- parentTbinfo = getRootTableInfo(tbinfo);
-
- /*
- * When we loading data through the root, we will qualify
- * the table name. This is needed because earlier
- * search_path will be set for the partition table.
- */
- classname = (char *) fmtQualifiedId(fout->remoteVersion,
- parentTbinfo->dobj.namespace->dobj.name,
- parentTbinfo->dobj.name);
- }
+ targettab = getRootTableInfo(tbinfo);
else
- classname = fmtId(tbinfo->dobj.name);
+ targettab = tbinfo;
appendPQExpBuffer(insertStmt, "INSERT INTO %s ",
- classname);
+ fmtQualifiedDumpable(targettab));
/* corner case for zero-column table */
if (nfields == 0)
TableInfo *parentTbinfo;
parentTbinfo = getRootTableInfo(tbinfo);
-
- /*
- * When we load data through the root, we will qualify the table
- * name, because search_path is set for the partition.
- */
- copyFrom = fmtQualifiedId(fout->remoteVersion,
- parentTbinfo->dobj.namespace->dobj.name,
- parentTbinfo->dobj.name);
+ copyFrom = fmtQualifiedDumpable(parentTbinfo);
}
else
- copyFrom = fmtId(tbinfo->dobj.name);
+ copyFrom = fmtQualifiedDumpable(tbinfo);
/* must use 2 steps here 'cause fmtId is nonreentrant */
appendPQExpBuffer(copyBuf, "COPY %s ",
q = createPQExpBuffer();
appendPQExpBuffer(q, "REFRESH MATERIALIZED VIEW %s;\n",
- fmtId(tbinfo->dobj.name));
+ fmtQualifiedDumpable(tbinfo));
if (tdinfo->dobj.dump & DUMP_COMPONENT_DATA)
ArchiveEntry(fout,
if (fout->remoteVersion < 90300)
return;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
query = createPQExpBuffer();
appendPQExpBufferStr(query, "WITH RECURSIVE w AS "
if (g_verbose)
write_msg(NULL, "saving database definition\n");
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/* Fetch the database-level properties for this database */
if (fout->remoteVersion >= 90600)
{
NULL, /* Dumper */
NULL); /* Dumper Arg */
- /* Compute correct tag for comments etc */
+ /* Compute correct tag for archive entry */
appendPQExpBuffer(labelq, "DATABASE %s", qdatname);
/* Dump DB comment if any */
}
else
{
- dumpComment(fout, labelq->data, NULL, dba,
+ dumpComment(fout, "DATABASE", qdatname, NULL, dba,
dbCatId, 0, dbDumpId);
}
* (pg_init_privs) on databases.
*/
dumpACL(fout, dbCatId, dbDumpId, "DATABASE",
- qdatname, NULL, labelq->data, NULL,
+ qdatname, NULL, NULL,
dba, datacl, rdatacl, "", "");
/*
destroyPQExpBuffer(qry);
}
+/*
+ * dumpSearchPath: record the active search_path in the archive
+ */
+static void
+dumpSearchPath(Archive *AH)
+{
+ PQExpBuffer qry = createPQExpBuffer();
+ PQExpBuffer path = createPQExpBuffer();
+ PGresult *res;
+ char **schemanames = NULL;
+ int nschemanames = 0;
+ int i;
+
+ /*
+ * We use the result of current_schemas(), not the search_path GUC,
+ * because that might contain wildcards such as "$user", which won't
+ * necessarily have the same value during restore. Also, this way avoids
+ * listing schemas that may appear in search_path but not actually exist,
+ * which seems like a prudent exclusion.
+ */
+ res = ExecuteSqlQueryForSingleRow(AH,
+ "SELECT pg_catalog.current_schemas(false)");
+
+ if (!parsePGArray(PQgetvalue(res, 0, 0), &schemanames, &nschemanames))
+ exit_horribly(NULL, "could not parse result of current_schemas()\n");
+
+ /*
+ * We use set_config(), not a simple "SET search_path" command, because
+ * the latter has less-clean behavior if the search path is empty. While
+ * that's likely to get fixed at some point, it seems like a good idea to
+ * be as backwards-compatible as possible in what we put into archives.
+ */
+ for (i = 0; i < nschemanames; i++)
+ {
+ if (i > 0)
+ appendPQExpBufferStr(path, ", ");
+ appendPQExpBufferStr(path, fmtId(schemanames[i]));
+ }
+
+ appendPQExpBufferStr(qry, "SELECT pg_catalog.set_config('search_path', ");
+ appendStringLiteralAH(qry, path->data, AH);
+ appendPQExpBufferStr(qry, ", false);\n");
+
+ if (g_verbose)
+ write_msg(NULL, "saving search_path = %s\n", path->data);
+
+ ArchiveEntry(AH, nilCatalogId, createDumpId(),
+ "SEARCHPATH", NULL, NULL, "",
+ false, "SEARCHPATH", SECTION_PRE_DATA,
+ qry->data, "", NULL,
+ NULL, 0,
+ NULL, NULL);
+
+ /* Also save it in AH->searchpath, in case we're doing plain text dump */
+ AH->searchpath = pg_strdup(qry->data);
+
+ if (schemanames)
+ free(schemanames);
+ PQclear(res);
+ destroyPQExpBuffer(qry);
+ destroyPQExpBuffer(path);
+}
+
/*
* getBlobs:
if (g_verbose)
write_msg(NULL, "reading large objects\n");
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/* Fetch BLOB OIDs, and owner/ACL data if >= 9.0 */
if (fout->remoteVersion >= 90600)
{
NULL, 0,
NULL, NULL);
- /* set up tag for comment and/or ACL */
- resetPQExpBuffer(cquery);
- appendPQExpBuffer(cquery, "LARGE OBJECT %s", binfo->dobj.name);
-
/* Dump comment if any */
if (binfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, cquery->data,
+ dumpComment(fout, "LARGE OBJECT", binfo->dobj.name,
NULL, binfo->rolname,
binfo->dobj.catId, 0, binfo->dobj.dumpId);
/* Dump security label if any */
if (binfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, cquery->data,
+ dumpSecLabel(fout, "LARGE OBJECT", binfo->dobj.name,
NULL, binfo->rolname,
binfo->dobj.catId, 0, binfo->dobj.dumpId);
/* Dump ACL if any */
if (binfo->blobacl && (binfo->dobj.dump & DUMP_COMPONENT_ACL))
dumpACL(fout, binfo->dobj.catId, binfo->dobj.dumpId, "LARGE OBJECT",
- binfo->dobj.name, NULL, cquery->data,
+ binfo->dobj.name, NULL,
NULL, binfo->rolname, binfo->blobacl, binfo->rblobacl,
binfo->initblobacl, binfo->initrblobacl);
if (g_verbose)
write_msg(NULL, "saving large objects\n");
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/*
* Currently, we re-fetch all BLOB OIDs using a cursor. Consider scanning
* the already-in-memory dumpable objects instead...
tbinfo->dobj.namespace->dobj.name,
tbinfo->dobj.name);
- /*
- * select table schema to ensure regproc name is qualified if needed
- */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
resetPQExpBuffer(query);
/* Get the policies for the table. */
query = createPQExpBuffer();
appendPQExpBuffer(query, "ALTER TABLE %s ENABLE ROW LEVEL SECURITY;",
- fmtId(polinfo->dobj.name));
+ fmtQualifiedDumpable(polinfo));
if (polinfo->dobj.dump & DUMP_COMPONENT_POLICY)
ArchiveEntry(fout, polinfo->dobj.catId, polinfo->dobj.dumpId,
appendPQExpBuffer(query, "CREATE POLICY %s", fmtId(polinfo->polname));
- appendPQExpBuffer(query, " ON %s%s%s", fmtId(tbinfo->dobj.name),
+ appendPQExpBuffer(query, " ON %s%s%s", fmtQualifiedDumpable(tbinfo),
!polinfo->polpermissive ? " AS RESTRICTIVE" : "", cmd);
if (polinfo->polroles != NULL)
appendPQExpBuffer(query, ";\n");
appendPQExpBuffer(delqry, "DROP POLICY %s", fmtId(polinfo->polname));
- appendPQExpBuffer(delqry, " ON %s;\n", fmtId(tbinfo->dobj.name));
+ appendPQExpBuffer(delqry, " ON %s;\n", fmtQualifiedDumpable(tbinfo));
tag = psprintf("%s %s", tbinfo->dobj.name, polinfo->dobj.name);
resetPQExpBuffer(query);
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/* Get the publications. */
appendPQExpBuffer(query,
"SELECT p.tableoid, p.oid, p.pubname, "
{
PQExpBuffer delq;
PQExpBuffer query;
- PQExpBuffer labelq;
+ char *qpubname;
bool first = true;
if (!(pubinfo->dobj.dump & DUMP_COMPONENT_DEFINITION))
delq = createPQExpBuffer();
query = createPQExpBuffer();
- labelq = createPQExpBuffer();
+
+ qpubname = pg_strdup(fmtId(pubinfo->dobj.name));
appendPQExpBuffer(delq, "DROP PUBLICATION %s;\n",
- fmtId(pubinfo->dobj.name));
+ qpubname);
appendPQExpBuffer(query, "CREATE PUBLICATION %s",
- fmtId(pubinfo->dobj.name));
-
- appendPQExpBuffer(labelq, "PUBLICATION %s", fmtId(pubinfo->dobj.name));
+ qpubname);
if (pubinfo->puballtables)
appendPQExpBufferStr(query, " FOR ALL TABLES");
NULL, NULL);
if (pubinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "PUBLICATION", qpubname,
NULL, pubinfo->rolname,
pubinfo->dobj.catId, 0, pubinfo->dobj.dumpId);
if (pubinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "PUBLICATION", qpubname,
NULL, pubinfo->rolname,
pubinfo->dobj.catId, 0, pubinfo->dobj.dumpId);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
+ free(qpubname);
}
/*
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
for (i = 0; i < numTables; i++)
{
TableInfo *tbinfo = &tblinfo[i];
appendPQExpBuffer(query, "ALTER PUBLICATION %s ADD TABLE ONLY",
fmtId(pubrinfo->pubname));
- appendPQExpBuffer(query, " %s;",
- fmtId(tbinfo->dobj.name));
+ appendPQExpBuffer(query, " %s;\n",
+ fmtQualifiedDumpable(tbinfo));
/*
* There is no point in creating drop query as drop query as the drop is
if (dopt->no_subscriptions || fout->remoteVersion < 100000)
return;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (!is_superuser(fout))
{
int n;
{
PQExpBuffer delq;
PQExpBuffer query;
- PQExpBuffer labelq;
PQExpBuffer publications;
+ char *qsubname;
char **pubnames = NULL;
int npubnames = 0;
int i;
delq = createPQExpBuffer();
query = createPQExpBuffer();
- labelq = createPQExpBuffer();
+
+ qsubname = pg_strdup(fmtId(subinfo->dobj.name));
appendPQExpBuffer(delq, "DROP SUBSCRIPTION %s;\n",
- fmtId(subinfo->dobj.name));
+ qsubname);
appendPQExpBuffer(query, "CREATE SUBSCRIPTION %s CONNECTION ",
- fmtId(subinfo->dobj.name));
+ qsubname);
appendStringLiteralAH(query, subinfo->subconninfo, fout);
/* Build list of quoted publications and append them to query. */
appendPQExpBufferStr(query, ");\n");
- appendPQExpBuffer(labelq, "SUBSCRIPTION %s", fmtId(subinfo->dobj.name));
-
ArchiveEntry(fout, subinfo->dobj.catId, subinfo->dobj.dumpId,
subinfo->dobj.name,
NULL,
NULL, NULL);
if (subinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "SUBSCRIPTION", qsubname,
NULL, subinfo->rolname,
subinfo->dobj.catId, 0, subinfo->dobj.dumpId);
if (subinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "SUBSCRIPTION", qsubname,
NULL, subinfo->rolname,
subinfo->dobj.catId, 0, subinfo->dobj.dumpId);
destroyPQExpBuffer(delq);
destroyPQExpBuffer(query);
+ free(qsubname);
}
static void
/*
* If the DumpableObject is a member of an extension, add a suitable
* ALTER EXTENSION ADD command to the creation commands in upgrade_buffer.
+ *
+ * For somewhat historical reasons, objname should already be quoted,
+ * but not objnamespace (if any).
*/
static void
binary_upgrade_extension_member(PQExpBuffer upgrade_buffer,
DumpableObject *dobj,
- const char *objlabel)
+ const char *objtype,
+ const char *objname,
+ const char *objnamespace)
{
DumpableObject *extobj = NULL;
int i;
extobj = NULL;
}
if (extobj == NULL)
- exit_horribly(NULL, "could not find parent extension for %s\n", objlabel);
+ exit_horribly(NULL, "could not find parent extension for %s %s\n",
+ objtype, objname);
appendPQExpBufferStr(upgrade_buffer,
"\n-- For binary upgrade, handle extension membership the hard way\n");
- appendPQExpBuffer(upgrade_buffer, "ALTER EXTENSION %s ADD %s;\n",
+ appendPQExpBuffer(upgrade_buffer, "ALTER EXTENSION %s ADD %s ",
fmtId(extobj->name),
- objlabel);
+ objtype);
+ if (objnamespace && *objnamespace)
+ appendPQExpBuffer(upgrade_buffer, "%s.", fmtId(objnamespace));
+ appendPQExpBuffer(upgrade_buffer, "%s;\n", objname);
}
/*
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/*
* we fetch all namespaces including system ones, so that every object we
* read in can be linked to a containing namespace.
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBufferStr(query, "SELECT x.tableoid, x.oid, "
"x.extname, n.nspname, x.extrelocatable, x.extversion, x.extconfig, x.extcondition "
"FROM pg_extension x "
* be revisited if the backend ever allows renaming of array types.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 90600)
{
PQExpBuffer acl_subquery = createPQExpBuffer();
* system-defined operators at dump-out time.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, oprname, "
"oprnamespace, "
"(%s oprowner) AS rolname, "
* system-defined collations at dump-out time.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, collname, "
"collnamespace, "
"(%s collowner) AS rolname "
* system-defined conversions at dump-out time.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, conname, "
"connamespace, "
"(%s conowner) AS rolname "
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/* Select all access methods from pg_am table */
appendPQExpBuffer(query, "SELECT tableoid, oid, amname, amtype, "
"amhandler::pg_catalog.regproc AS amhandler "
* system-defined opclasses at dump-out time.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, opcname, "
"opcnamespace, "
"(%s opcowner) AS rolname "
* system-defined opfamilies at dump-out time.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, opfname, "
"opfnamespace, "
"(%s opfowner) AS rolname "
int i_initaggacl;
int i_initraggacl;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/*
* Find all interesting aggregates. See comment in getFuncs() for the
* rationale behind the filtering logic.
int i_initproacl;
int i_initrproacl;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/*
* Find all interesting functions. This is a bit complicated:
*
int i_ispartition;
int i_partbound;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/*
* Find all the tables and table-like objects.
*
resetPQExpBuffer(query);
appendPQExpBuffer(query,
"LOCK TABLE %s IN ACCESS SHARE MODE",
- fmtQualifiedId(fout->remoteVersion,
- tblinfo[i].dobj.namespace->dobj.name,
- tblinfo[i].dobj.name));
+ fmtQualifiedDumpable(&tblinfo[i]));
ExecuteSqlStatement(fout, query->data);
}
int i_inhrelid;
int i_inhparent;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
/*
* Find all the inheritance information, excluding implicit inheritance
* via partitioning. We handle that case using getPartitions(), because
tbinfo->dobj.namespace->dobj.name,
tbinfo->dobj.name);
- /* Make sure we are in proper schema so indexdef is right */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
/*
* The point of the messy-looking outer join is to find a constraint
* that is related by an internal dependency link to the index. If we
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, stxname, "
"stxnamespace, (%s stxowner) AS rolname "
"FROM pg_catalog.pg_statistic_ext",
tbinfo->dobj.namespace->dobj.name,
tbinfo->dobj.name);
- /*
- * select table schema to ensure constraint expr is qualified if
- * needed
- */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
resetPQExpBuffer(query);
appendPQExpBuffer(query,
"SELECT tableoid, oid, conname, confrelid, "
i_consrc;
int ntups;
- /*
- * select appropriate schema to ensure names in constraint are properly
- * qualified
- */
- selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
-
query = createPQExpBuffer();
if (fout->remoteVersion >= 90100)
int i_is_instead;
int i_ev_enabled;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 80300)
{
appendPQExpBufferStr(query, "SELECT "
tbinfo->dobj.namespace->dobj.name,
tbinfo->dobj.name);
- /*
- * select table schema to ensure regproc name is qualified if needed
- */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
resetPQExpBuffer(query);
if (fout->remoteVersion >= 90000)
{
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query,
"SELECT e.tableoid, e.oid, evtname, evtenabled, "
"evtevent, (%s evtowner) AS evtowner, "
int i_initrlanacl;
int i_lanowner;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 90600)
{
PQExpBuffer acl_subquery = createPQExpBuffer();
int i_castcontext;
int i_castmethod;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 80400)
{
appendPQExpBufferStr(query, "SELECT tableoid, oid, "
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, "
"trftype, trflang, trffromsql::oid, trftosql::oid "
"FROM pg_transform "
if (!tbinfo->interesting)
continue;
- /*
- * Make sure we are in proper schema for this table; this allows
- * correct retrieval of formatted type names and default exprs
- */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
-
/* find all the user attributes and their types */
/*
* system-defined objects at dump-out time.
*/
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBufferStr(query, "SELECT tableoid, oid, prsname, prsnamespace, "
"prsstart::oid, prstoken::oid, "
"prsend::oid, prsheadline::oid, prslextype::oid "
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, dictname, "
"dictnamespace, (%s dictowner) AS rolname, "
"dicttemplate, dictinitoption "
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBufferStr(query, "SELECT tableoid, oid, tmplname, "
"tmplnamespace, tmplinit::oid, tmpllexize::oid "
"FROM pg_ts_template");
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query, "SELECT tableoid, oid, cfgname, "
"cfgnamespace, (%s cfgowner) AS rolname, cfgparser "
"FROM pg_ts_config",
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 90600)
{
PQExpBuffer acl_subquery = createPQExpBuffer();
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 90600)
{
PQExpBuffer acl_subquery = createPQExpBuffer();
query = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 90600)
{
PQExpBuffer acl_subquery = createPQExpBuffer();
* dumpComment --
*
* This routine is used to dump any comments associated with the
- * object handed to this routine. The routine takes a constant character
- * string for the target part of the comment-creation command, plus
+ * object handed to this routine. The routine takes the object type
+ * and object name (ready to print, except for schema decoration), plus
* the namespace and owner of the object (for labeling the ArchiveEntry),
* plus catalog ID and subid which are the lookup key for pg_description,
* plus the dump ID for the object (for setting a dependency).
* If a matching pg_description entry is found, it is dumped.
*
+ * Note: in some cases, such as comments for triggers and rules, the "type"
+ * string really looks like, e.g., "TRIGGER name ON". This is a bit of a hack
+ * but it doesn't seem worth complicating the API for all callers to make
+ * it cleaner.
+ *
* Note: although this routine takes a dumpId for dependency purposes,
* that purpose is just to mark the dependency in the emitted dump file
* for possible future use by pg_restore. We do NOT use it for determining
* calling ArchiveEntry() for the specified object.
*/
static void
-dumpComment(Archive *fout, const char *target,
+dumpComment(Archive *fout, const char *type, const char *name,
const char *namespace, const char *owner,
CatalogId catalogId, int subid, DumpId dumpId)
{
return;
/* Comments are schema not data ... except blob comments are data */
- if (strncmp(target, "LARGE OBJECT ", 13) != 0)
+ if (strcmp(type, "LARGE OBJECT") != 0)
{
if (dopt->dataOnly)
return;
if (ncomments > 0)
{
PQExpBuffer query = createPQExpBuffer();
+ PQExpBuffer tag = createPQExpBuffer();
- appendPQExpBuffer(query, "COMMENT ON %s IS ", target);
+ appendPQExpBuffer(query, "COMMENT ON %s ", type);
+ if (namespace && *namespace)
+ appendPQExpBuffer(query, "%s.", fmtId(namespace));
+ appendPQExpBuffer(query, "%s IS ", name);
appendStringLiteralAH(query, comments->descr, fout);
appendPQExpBufferStr(query, ";\n");
+ appendPQExpBuffer(tag, "%s %s", type, name);
+
/*
* We mark comments as SECTION_NONE because they really belong in the
* same section as their parent, whether that is pre-data or
* post-data.
*/
ArchiveEntry(fout, nilCatalogId, createDumpId(),
- target, namespace, NULL, owner,
+ tag->data, namespace, NULL, owner,
false, "COMMENT", SECTION_NONE,
query->data, "", NULL,
&(dumpId), 1,
NULL, NULL);
destroyPQExpBuffer(query);
+ destroyPQExpBuffer(tag);
}
}
CommentItem *comments;
int ncomments;
PQExpBuffer query;
- PQExpBuffer target;
+ PQExpBuffer tag;
/* do nothing, if --no-comments is supplied */
if (dopt->no_comments)
return;
query = createPQExpBuffer();
- target = createPQExpBuffer();
+ tag = createPQExpBuffer();
while (ncomments > 0)
{
if (objsubid == 0)
{
- resetPQExpBuffer(target);
- appendPQExpBuffer(target, "%s %s", reltypename,
+ resetPQExpBuffer(tag);
+ appendPQExpBuffer(tag, "%s %s", reltypename,
fmtId(tbinfo->dobj.name));
resetPQExpBuffer(query);
- appendPQExpBuffer(query, "COMMENT ON %s IS ", target->data);
+ appendPQExpBuffer(query, "COMMENT ON %s %s IS ", reltypename,
+ fmtQualifiedDumpable(tbinfo));
appendStringLiteralAH(query, descr, fout);
appendPQExpBufferStr(query, ";\n");
ArchiveEntry(fout, nilCatalogId, createDumpId(),
- target->data,
+ tag->data,
tbinfo->dobj.namespace->dobj.name,
NULL, tbinfo->rolname,
false, "COMMENT", SECTION_NONE,
}
else if (objsubid > 0 && objsubid <= tbinfo->numatts)
{
- resetPQExpBuffer(target);
- appendPQExpBuffer(target, "COLUMN %s.",
+ resetPQExpBuffer(tag);
+ appendPQExpBuffer(tag, "COLUMN %s.",
fmtId(tbinfo->dobj.name));
- appendPQExpBufferStr(target, fmtId(tbinfo->attnames[objsubid - 1]));
+ appendPQExpBufferStr(tag, fmtId(tbinfo->attnames[objsubid - 1]));
resetPQExpBuffer(query);
- appendPQExpBuffer(query, "COMMENT ON %s IS ", target->data);
+ appendPQExpBuffer(query, "COMMENT ON COLUMN %s.",
+ fmtQualifiedDumpable(tbinfo));
+ appendPQExpBuffer(query, "%s IS ",
+ fmtId(tbinfo->attnames[objsubid - 1]));
appendStringLiteralAH(query, descr, fout);
appendPQExpBufferStr(query, ";\n");
ArchiveEntry(fout, nilCatalogId, createDumpId(),
- target->data,
+ tag->data,
tbinfo->dobj.namespace->dobj.name,
NULL, tbinfo->rolname,
false, "COMMENT", SECTION_NONE,
}
destroyPQExpBuffer(query);
- destroyPQExpBuffer(target);
+ destroyPQExpBuffer(tag);
}
/*
int i;
CommentItem *comments;
- /*
- * Note we do NOT change source schema here; preserve the caller's
- * setting, instead.
- */
-
query = createPQExpBuffer();
appendPQExpBufferStr(query, "SELECT description, classoid, objoid, objsubid "
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
char *qnspname;
/* Skip if not to be dumped */
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
qnspname = pg_strdup(fmtId(nspinfo->dobj.name));
appendPQExpBuffer(q, "CREATE SCHEMA %s;\n", qnspname);
- appendPQExpBuffer(labelq, "SCHEMA %s", qnspname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &nspinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &nspinfo->dobj,
+ "SCHEMA", qnspname, NULL);
if (nspinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId,
/* Dump Schema Comments and Security Labels */
if (nspinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "SCHEMA", qnspname,
NULL, nspinfo->rolname,
nspinfo->dobj.catId, 0, nspinfo->dobj.dumpId);
if (nspinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "SCHEMA", qnspname,
NULL, nspinfo->rolname,
nspinfo->dobj.catId, 0, nspinfo->dobj.dumpId);
if (nspinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, nspinfo->dobj.catId, nspinfo->dobj.dumpId, "SCHEMA",
- qnspname, NULL, labelq->data, NULL,
+ qnspname, NULL, NULL,
nspinfo->rolname, nspinfo->nspacl, nspinfo->rnspacl,
nspinfo->initnspacl, nspinfo->initrnspacl);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
char *qextname;
/* Skip if not to be dumped */
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
qextname = pg_strdup(fmtId(extinfo->dobj.name));
appendPQExpBufferStr(q, ");\n");
}
- appendPQExpBuffer(labelq, "EXTENSION %s", qextname);
-
if (extinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, extinfo->dobj.catId, extinfo->dobj.dumpId,
extinfo->dobj.name,
/* Dump Extension Comments and Security Labels */
if (extinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "EXTENSION", qextname,
NULL, "",
extinfo->dobj.catId, 0, extinfo->dobj.dumpId);
if (extinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "EXTENSION", qextname,
NULL, "",
extinfo->dobj.catId, 0, extinfo->dobj.dumpId);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
PQExpBuffer query = createPQExpBuffer();
PGresult *res;
int num,
i;
Oid enum_oid;
char *qtypname;
+ char *qualtypname;
char *label;
- /* Set proper schema search path */
- selectSourceSchema(fout, "pg_catalog");
-
if (fout->remoteVersion >= 90100)
appendPQExpBuffer(query, "SELECT oid, enumlabel "
"FROM pg_catalog.pg_enum "
num = PQntuples(res);
qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
+ qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
/*
- * DROP must be fully qualified in case same name appears in pg_catalog.
* CASCADE shouldn't be required here as for normal types since the I/O
* functions are generic and do not get dropped.
*/
- appendPQExpBuffer(delq, "DROP TYPE %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- qtypname);
+ appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
if (dopt->binary_upgrade)
binary_upgrade_set_type_oids_by_type_oid(fout, q,
false);
appendPQExpBuffer(q, "CREATE TYPE %s AS ENUM (",
- qtypname);
+ qualtypname);
if (!dopt->binary_upgrade)
{
appendPQExpBuffer(q,
"SELECT pg_catalog.binary_upgrade_set_next_pg_enum_oid('%u'::pg_catalog.oid);\n",
enum_oid);
- appendPQExpBuffer(q, "ALTER TYPE %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(q, "%s ADD VALUE ",
- qtypname);
+ appendPQExpBuffer(q, "ALTER TYPE %s ADD VALUE ", qualtypname);
appendStringLiteralAH(q, label, fout);
appendPQExpBufferStr(q, ";\n\n");
}
}
- appendPQExpBuffer(labelq, "TYPE %s", qtypname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tyinfo->dobj,
+ "TYPE", qtypname,
+ tyinfo->dobj.namespace->dobj.name);
if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
/* Dump Type Comments and Security Labels */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
- qtypname, NULL, labelq->data,
+ qtypname, NULL,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname, tyinfo->typacl, tyinfo->rtypacl,
tyinfo->inittypacl, tyinfo->initrtypacl);
PQclear(res);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qtypname);
+ free(qualtypname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
PQExpBuffer query = createPQExpBuffer();
PGresult *res;
Oid collationOid;
char *qtypname;
+ char *qualtypname;
char *procname;
- /*
- * select appropriate schema to ensure names in CREATE are properly
- * qualified
- */
- selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
-
appendPQExpBuffer(query,
"SELECT pg_catalog.format_type(rngsubtype, NULL) AS rngsubtype, "
"opc.opcname AS opcname, "
res = ExecuteSqlQueryForSingleRow(fout, query->data);
qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
+ qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
/*
- * DROP must be fully qualified in case same name appears in pg_catalog.
* CASCADE shouldn't be required here as for normal types since the I/O
* functions are generic and do not get dropped.
*/
- appendPQExpBuffer(delq, "DROP TYPE %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- qtypname);
+ appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
if (dopt->binary_upgrade)
binary_upgrade_set_type_oids_by_type_oid(fout, q,
false);
appendPQExpBuffer(q, "CREATE TYPE %s AS RANGE (",
- qtypname);
+ qualtypname);
appendPQExpBuffer(q, "\n subtype = %s",
PQgetvalue(res, 0, PQfnumber(res, "rngsubtype")));
char *opcname = PQgetvalue(res, 0, PQfnumber(res, "opcname"));
char *nspname = PQgetvalue(res, 0, PQfnumber(res, "opcnsp"));
- /* always schema-qualify, don't try to be smart */
appendPQExpBuffer(q, ",\n subtype_opclass = %s.",
fmtId(nspname));
appendPQExpBufferStr(q, fmtId(opcname));
CollInfo *coll = findCollationByOid(collationOid);
if (coll)
- {
- /* always schema-qualify, don't try to be smart */
- appendPQExpBuffer(q, ",\n collation = %s.",
- fmtId(coll->dobj.namespace->dobj.name));
- appendPQExpBufferStr(q, fmtId(coll->dobj.name));
- }
+ appendPQExpBuffer(q, ",\n collation = %s",
+ fmtQualifiedDumpable(coll));
}
procname = PQgetvalue(res, 0, PQfnumber(res, "rngcanonical"));
appendPQExpBufferStr(q, "\n);\n");
- appendPQExpBuffer(labelq, "TYPE %s", qtypname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tyinfo->dobj,
+ "TYPE", qtypname,
+ tyinfo->dobj.namespace->dobj.name);
if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
/* Dump Type Comments and Security Labels */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
- qtypname, NULL, labelq->data,
+ qtypname, NULL,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname, tyinfo->typacl, tyinfo->rtypacl,
tyinfo->inittypacl, tyinfo->initrtypacl);
PQclear(res);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qtypname);
+ free(qualtypname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
char *qtypname;
+ char *qualtypname;
qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
+ qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog.
- */
- appendPQExpBuffer(delq, "DROP TYPE %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- qtypname);
+ appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
if (dopt->binary_upgrade)
binary_upgrade_set_type_oids_by_type_oid(fout, q,
false);
appendPQExpBuffer(q, "CREATE TYPE %s;\n",
- qtypname);
-
- appendPQExpBuffer(labelq, "TYPE %s", qtypname);
+ qualtypname);
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tyinfo->dobj,
+ "TYPE", qtypname,
+ tyinfo->dobj.namespace->dobj.name);
if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
/* Dump Type Comments and Security Labels */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
- qtypname, NULL, labelq->data,
+ qtypname, NULL,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname, tyinfo->typacl, tyinfo->rtypacl,
tyinfo->inittypacl, tyinfo->initrtypacl);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qtypname);
+ free(qualtypname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
PQExpBuffer query = createPQExpBuffer();
PGresult *res;
char *qtypname;
+ char *qualtypname;
char *typlen;
char *typinput;
char *typoutput;
char *typdefault;
bool typdefault_is_literal = false;
- /* Set proper schema search path so regproc references list correctly */
- selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
-
/* Fetch type-specific details */
if (fout->remoteVersion >= 90100)
{
typdefault = NULL;
qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
+ qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
/*
- * DROP must be fully qualified in case same name appears in pg_catalog.
* The reason we include CASCADE is that the circular dependency between
* the type and its I/O functions makes it impossible to drop the type any
* other way.
*/
- appendPQExpBuffer(delq, "DROP TYPE %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s CASCADE;\n",
- qtypname);
+ appendPQExpBuffer(delq, "DROP TYPE %s CASCADE;\n", qualtypname);
/*
* We might already have a shell type, but setting pg_type_oid is
appendPQExpBuffer(q,
"CREATE TYPE %s (\n"
" INTERNALLENGTH = %s",
- qtypname,
+ qualtypname,
(strcmp(typlen, "-1") == 0) ? "variable" : typlen);
/* regproc result is sufficiently quoted already */
{
char *elemType;
- /* reselect schema in case changed by function dump */
- selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
elemType = getFormattedTypeName(fout, tyinfo->typelem, zeroAsOpaque);
appendPQExpBuffer(q, ",\n ELEMENT = %s", elemType);
free(elemType);
appendPQExpBufferStr(q, "\n);\n");
- appendPQExpBuffer(labelq, "TYPE %s", qtypname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tyinfo->dobj,
+ "TYPE", qtypname,
+ tyinfo->dobj.namespace->dobj.name);
if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
/* Dump Type Comments and Security Labels */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
- qtypname, NULL, labelq->data,
+ qtypname, NULL,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname, tyinfo->typacl, tyinfo->rtypacl,
tyinfo->inittypacl, tyinfo->initrtypacl);
PQclear(res);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qtypname);
+ free(qualtypname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
PQExpBuffer query = createPQExpBuffer();
PGresult *res;
int i;
char *qtypname;
+ char *qualtypname;
char *typnotnull;
char *typdefn;
char *typdefault;
Oid typcollation;
bool typdefault_is_literal = false;
- /* Set proper schema search path so type references list correctly */
- selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
-
/* Fetch domain specific details */
if (fout->remoteVersion >= 90100)
{
true); /* force array type */
qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
+ qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
appendPQExpBuffer(q,
"CREATE DOMAIN %s AS %s",
- qtypname,
+ qualtypname,
typdefn);
/* Print collation only if different from base type's collation */
coll = findCollationByOid(typcollation);
if (coll)
- {
- /* always schema-qualify, don't try to be smart */
- appendPQExpBuffer(q, " COLLATE %s.",
- fmtId(coll->dobj.namespace->dobj.name));
- appendPQExpBufferStr(q, fmtId(coll->dobj.name));
- }
+ appendPQExpBuffer(q, " COLLATE %s", fmtQualifiedDumpable(coll));
}
if (typnotnull[0] == 't')
appendPQExpBufferStr(q, ";\n");
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP DOMAIN %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- qtypname);
-
- appendPQExpBuffer(labelq, "DOMAIN %s", qtypname);
+ appendPQExpBuffer(delq, "DROP DOMAIN %s;\n", qualtypname);
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tyinfo->dobj,
+ "DOMAIN", qtypname,
+ tyinfo->dobj.namespace->dobj.name);
if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
/* Dump Domain Comments and Security Labels */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "DOMAIN", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "DOMAIN", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
- qtypname, NULL, labelq->data,
+ qtypname, NULL,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname, tyinfo->typacl, tyinfo->rtypacl,
tyinfo->inittypacl, tyinfo->initrtypacl);
for (i = 0; i < tyinfo->nDomChecks; i++)
{
ConstraintInfo *domcheck = &(tyinfo->domChecks[i]);
- PQExpBuffer labelq = createPQExpBuffer();
+ PQExpBuffer conprefix = createPQExpBuffer();
- appendPQExpBuffer(labelq, "CONSTRAINT %s ",
+ appendPQExpBuffer(conprefix, "CONSTRAINT %s ON DOMAIN",
fmtId(domcheck->dobj.name));
- appendPQExpBuffer(labelq, "ON DOMAIN %s",
- qtypname);
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, conprefix->data, qtypname,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname,
domcheck->dobj.catId, 0, tyinfo->dobj.dumpId);
- destroyPQExpBuffer(labelq);
+ destroyPQExpBuffer(conprefix);
}
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qtypname);
+ free(qualtypname);
}
/*
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer dropped = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
PQExpBuffer query = createPQExpBuffer();
PGresult *res;
char *qtypname;
+ char *qualtypname;
int ntups;
int i_attname;
int i_atttypdefn;
int i;
int actual_atts;
- /* Set proper schema search path so type references list correctly */
- selectSourceSchema(fout, tyinfo->dobj.namespace->dobj.name);
-
/* Fetch type specific details */
if (fout->remoteVersion >= 90100)
{
}
qtypname = pg_strdup(fmtId(tyinfo->dobj.name));
+ qualtypname = pg_strdup(fmtQualifiedDumpable(tyinfo));
appendPQExpBuffer(q, "CREATE TYPE %s AS (",
- qtypname);
+ qualtypname);
actual_atts = 0;
for (i = 0; i < ntups; i++)
coll = findCollationByOid(attcollation);
if (coll)
- {
- /* always schema-qualify, don't try to be smart */
- appendPQExpBuffer(q, " COLLATE %s.",
- fmtId(coll->dobj.namespace->dobj.name));
- appendPQExpBufferStr(q, fmtId(coll->dobj.name));
- }
+ appendPQExpBuffer(q, " COLLATE %s",
+ fmtQualifiedDumpable(coll));
}
}
else
"WHERE attname = ", attlen, attalign);
appendStringLiteralAH(dropped, attname, fout);
appendPQExpBufferStr(dropped, "\n AND attrelid = ");
- appendStringLiteralAH(dropped, qtypname, fout);
+ appendStringLiteralAH(dropped, qualtypname, fout);
appendPQExpBufferStr(dropped, "::pg_catalog.regclass;\n");
appendPQExpBuffer(dropped, "ALTER TYPE %s ",
- qtypname);
+ qualtypname);
appendPQExpBuffer(dropped, "DROP ATTRIBUTE %s;\n",
fmtId(attname));
}
appendPQExpBufferStr(q, "\n);\n");
appendPQExpBufferStr(q, dropped->data);
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP TYPE %s.",
- fmtId(tyinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- qtypname);
-
- appendPQExpBuffer(labelq, "TYPE %s", qtypname);
+ appendPQExpBuffer(delq, "DROP TYPE %s;\n", qualtypname);
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tyinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tyinfo->dobj,
+ "TYPE", qtypname,
+ tyinfo->dobj.namespace->dobj.name);
if (tyinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
/* Dump Type Comments and Security Labels */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "TYPE", qtypname,
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
if (tyinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId, "TYPE",
- qtypname, NULL, labelq->data,
+ qtypname, NULL,
tyinfo->dobj.namespace->dobj.name,
tyinfo->rolname, tyinfo->typacl, tyinfo->rtypacl,
tyinfo->inittypacl, tyinfo->initrtypacl);
destroyPQExpBuffer(q);
destroyPQExpBuffer(dropped);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qtypname);
+ free(qualtypname);
/* Dump any per-column comments */
if (tyinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
appendPQExpBufferStr(target, fmtId(attname));
resetPQExpBuffer(query);
- appendPQExpBuffer(query, "COMMENT ON %s IS ", target->data);
+ appendPQExpBuffer(query, "COMMENT ON COLUMN %s.",
+ fmtQualifiedDumpable(tyinfo));
+ appendPQExpBuffer(query, "%s IS ", fmtId(attname));
appendStringLiteralAH(query, descr, fout);
appendPQExpBufferStr(query, ";\n");
false);
appendPQExpBuffer(q, "CREATE TYPE %s;\n",
- fmtId(stinfo->dobj.name));
+ fmtQualifiedDumpable(stinfo));
if (stinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, stinfo->dobj.catId, stinfo->dobj.dumpId,
DumpOptions *dopt = fout->dopt;
PQExpBuffer defqry;
PQExpBuffer delqry;
- PQExpBuffer labelq;
bool useParams;
char *qlanname;
- char *lanschema;
FuncInfo *funcInfo;
FuncInfo *inlineInfo = NULL;
FuncInfo *validatorInfo = NULL;
defqry = createPQExpBuffer();
delqry = createPQExpBuffer();
- labelq = createPQExpBuffer();
qlanname = pg_strdup(fmtId(plang->dobj.name));
- /*
- * If dumping a HANDLER clause, treat the language as being in the handler
- * function's schema; this avoids cluttering the HANDLER clause. Otherwise
- * it doesn't really have a schema.
- */
- if (useParams)
- lanschema = funcInfo->dobj.namespace->dobj.name;
- else
- lanschema = NULL;
-
appendPQExpBuffer(delqry, "DROP PROCEDURAL LANGUAGE %s;\n",
qlanname);
plang->lanpltrusted ? "TRUSTED " : "",
qlanname);
appendPQExpBuffer(defqry, " HANDLER %s",
- fmtId(funcInfo->dobj.name));
+ fmtQualifiedDumpable(funcInfo));
if (OidIsValid(plang->laninline))
- {
- appendPQExpBufferStr(defqry, " INLINE ");
- /* Cope with possibility that inline is in different schema */
- if (inlineInfo->dobj.namespace != funcInfo->dobj.namespace)
- appendPQExpBuffer(defqry, "%s.",
- fmtId(inlineInfo->dobj.namespace->dobj.name));
- appendPQExpBufferStr(defqry, fmtId(inlineInfo->dobj.name));
- }
+ appendPQExpBuffer(defqry, " INLINE %s",
+ fmtQualifiedDumpable(inlineInfo));
if (OidIsValid(plang->lanvalidator))
- {
- appendPQExpBufferStr(defqry, " VALIDATOR ");
- /* Cope with possibility that validator is in different schema */
- if (validatorInfo->dobj.namespace != funcInfo->dobj.namespace)
- appendPQExpBuffer(defqry, "%s.",
- fmtId(validatorInfo->dobj.namespace->dobj.name));
- appendPQExpBufferStr(defqry, fmtId(validatorInfo->dobj.name));
- }
+ appendPQExpBuffer(defqry, " VALIDATOR %s",
+ fmtQualifiedDumpable(validatorInfo));
}
else
{
}
appendPQExpBufferStr(defqry, ";\n");
- appendPQExpBuffer(labelq, "LANGUAGE %s", qlanname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(defqry, &plang->dobj, labelq->data);
+ binary_upgrade_extension_member(defqry, &plang->dobj,
+ "LANGUAGE", qlanname, NULL);
if (plang->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, plang->dobj.catId, plang->dobj.dumpId,
plang->dobj.name,
- lanschema, NULL, plang->lanowner,
+ NULL, NULL, plang->lanowner,
false, "PROCEDURAL LANGUAGE", SECTION_PRE_DATA,
defqry->data, delqry->data, NULL,
NULL, 0,
/* Dump Proc Lang Comments and Security Labels */
if (plang->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
- lanschema, plang->lanowner,
+ dumpComment(fout, "LANGUAGE", qlanname,
+ NULL, plang->lanowner,
plang->dobj.catId, 0, plang->dobj.dumpId);
if (plang->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
- lanschema, plang->lanowner,
+ dumpSecLabel(fout, "LANGUAGE", qlanname,
+ NULL, plang->lanowner,
plang->dobj.catId, 0, plang->dobj.dumpId);
if (plang->lanpltrusted && plang->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, plang->dobj.catId, plang->dobj.dumpId, "LANGUAGE",
- qlanname, NULL, labelq->data,
- lanschema,
+ qlanname, NULL, NULL,
plang->lanowner, plang->lanacl, plang->rlanacl,
plang->initlanacl, plang->initrlanacl);
destroyPQExpBuffer(defqry);
destroyPQExpBuffer(delqry);
- destroyPQExpBuffer(labelq);
}
/*
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delqry;
- PQExpBuffer labelq;
PQExpBuffer asPart;
PGresult *res;
char *funcsig; /* identity signature */
query = createPQExpBuffer();
q = createPQExpBuffer();
delqry = createPQExpBuffer();
- labelq = createPQExpBuffer();
asPart = createPQExpBuffer();
- /* Set proper schema search path so type references list correctly */
- selectSourceSchema(fout, finfo->dobj.namespace->dobj.name);
-
/* Fetch function-specific details */
if (fout->remoteVersion >= 90600)
{
keyword = is_procedure ? "PROCEDURE" : "FUNCTION";
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
appendPQExpBuffer(delqry, "DROP %s %s.%s;\n",
keyword,
fmtId(finfo->dobj.namespace->dobj.name),
funcsig);
- appendPQExpBuffer(q, "CREATE %s %s",
+ appendPQExpBuffer(q, "CREATE %s %s.%s",
keyword,
+ fmtId(finfo->dobj.namespace->dobj.name),
funcfullsig ? funcfullsig :
funcsig);
+
if (is_procedure)
;
else if (funcresult)
appendPQExpBuffer(q, "\n %s;\n", asPart->data);
- appendPQExpBuffer(labelq, "%s %s", keyword, funcsig);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &finfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &finfo->dobj,
+ keyword, funcsig,
+ finfo->dobj.namespace->dobj.name);
if (finfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, finfo->dobj.catId, finfo->dobj.dumpId,
/* Dump Function Comments and Security Labels */
if (finfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, keyword, funcsig,
finfo->dobj.namespace->dobj.name, finfo->rolname,
finfo->dobj.catId, 0, finfo->dobj.dumpId);
if (finfo->dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, keyword, funcsig,
finfo->dobj.namespace->dobj.name, finfo->rolname,
finfo->dobj.catId, 0, finfo->dobj.dumpId);
if (finfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, finfo->dobj.catId, finfo->dobj.dumpId, keyword,
- funcsig, NULL, labelq->data,
+ funcsig, NULL,
finfo->dobj.namespace->dobj.name,
finfo->rolname, finfo->proacl, finfo->rproacl,
finfo->initproacl, finfo->initrproacl);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delqry);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(asPart);
free(funcsig);
if (funcfullsig)
PQExpBuffer defqry;
PQExpBuffer delqry;
PQExpBuffer labelq;
+ PQExpBuffer castargs;
FuncInfo *funcInfo = NULL;
char *sourceType;
char *targetType;
cast->castfunc);
}
- /*
- * Make sure we are in proper schema (needed for getFormattedTypeName).
- * Casts don't have a schema of their own, so use pg_catalog.
- */
- selectSourceSchema(fout, "pg_catalog");
-
defqry = createPQExpBuffer();
delqry = createPQExpBuffer();
labelq = createPQExpBuffer();
+ castargs = createPQExpBuffer();
sourceType = getFormattedTypeName(fout, cast->castsource, zeroAsNone);
targetType = getFormattedTypeName(fout, cast->casttarget, zeroAsNone);
char *fsig = format_function_signature(fout, funcInfo, true);
/*
- * Always qualify the function name, in case it is not in
- * pg_catalog schema (format_function_signature won't qualify
- * it).
+ * Always qualify the function name (format_function_signature
+ * won't qualify it).
*/
appendPQExpBuffer(defqry, "WITH FUNCTION %s.%s",
fmtId(funcInfo->dobj.namespace->dobj.name), fsig);
appendPQExpBuffer(labelq, "CAST (%s AS %s)",
sourceType, targetType);
+ appendPQExpBuffer(castargs, "(%s AS %s)",
+ sourceType, targetType);
+
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(defqry, &cast->dobj, labelq->data);
+ binary_upgrade_extension_member(defqry, &cast->dobj,
+ "CAST", castargs->data, NULL);
if (cast->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, cast->dobj.catId, cast->dobj.dumpId,
labelq->data,
- "pg_catalog", NULL, "",
+ NULL, NULL, "",
false, "CAST", SECTION_PRE_DATA,
defqry->data, delqry->data, NULL,
NULL, 0,
/* Dump Cast Comments */
if (cast->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
- "pg_catalog", "",
+ dumpComment(fout, "CAST", castargs->data,
+ NULL, "",
cast->dobj.catId, 0, cast->dobj.dumpId);
free(sourceType);
destroyPQExpBuffer(defqry);
destroyPQExpBuffer(delqry);
destroyPQExpBuffer(labelq);
+ destroyPQExpBuffer(castargs);
}
/*
PQExpBuffer defqry;
PQExpBuffer delqry;
PQExpBuffer labelq;
+ PQExpBuffer transformargs;
FuncInfo *fromsqlFuncInfo = NULL;
FuncInfo *tosqlFuncInfo = NULL;
char *lanname;
transform->trftosql);
}
- /* Make sure we are in proper schema (needed for getFormattedTypeName) */
- selectSourceSchema(fout, "pg_catalog");
-
defqry = createPQExpBuffer();
delqry = createPQExpBuffer();
labelq = createPQExpBuffer();
+ transformargs = createPQExpBuffer();
lanname = get_language_name(fout, transform->trflang);
transformType = getFormattedTypeName(fout, transform->trftype, zeroAsNone);
char *fsig = format_function_signature(fout, fromsqlFuncInfo, true);
/*
- * Always qualify the function name, in case it is not in
- * pg_catalog schema (format_function_signature won't qualify it).
+ * Always qualify the function name (format_function_signature
+ * won't qualify it).
*/
appendPQExpBuffer(defqry, "FROM SQL WITH FUNCTION %s.%s",
fmtId(fromsqlFuncInfo->dobj.namespace->dobj.name), fsig);
char *fsig = format_function_signature(fout, tosqlFuncInfo, true);
/*
- * Always qualify the function name, in case it is not in
- * pg_catalog schema (format_function_signature won't qualify it).
+ * Always qualify the function name (format_function_signature
+ * won't qualify it).
*/
appendPQExpBuffer(defqry, "TO SQL WITH FUNCTION %s.%s",
fmtId(tosqlFuncInfo->dobj.namespace->dobj.name), fsig);
appendPQExpBuffer(labelq, "TRANSFORM FOR %s LANGUAGE %s",
transformType, lanname);
+ appendPQExpBuffer(transformargs, "FOR %s LANGUAGE %s",
+ transformType, lanname);
+
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(defqry, &transform->dobj, labelq->data);
+ binary_upgrade_extension_member(defqry, &transform->dobj,
+ "TRANSFORM", transformargs->data, NULL);
if (transform->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, transform->dobj.catId, transform->dobj.dumpId,
labelq->data,
- "pg_catalog", NULL, "",
+ NULL, NULL, "",
false, "TRANSFORM", SECTION_PRE_DATA,
defqry->data, delqry->data, NULL,
transform->dobj.dependencies, transform->dobj.nDeps,
/* Dump Transform Comments */
if (transform->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
- "pg_catalog", "",
+ dumpComment(fout, "TRANSFORM", transformargs->data,
+ NULL, "",
transform->dobj.catId, 0, transform->dobj.dumpId);
free(lanname);
destroyPQExpBuffer(defqry);
destroyPQExpBuffer(delqry);
destroyPQExpBuffer(labelq);
+ destroyPQExpBuffer(transformargs);
}
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
PQExpBuffer oprid;
PQExpBuffer details;
PGresult *res;
query = createPQExpBuffer();
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
oprid = createPQExpBuffer();
details = createPQExpBuffer();
- /* Make sure we are in proper schema so regoperator works correctly */
- selectSourceSchema(fout, oprinfo->dobj.namespace->dobj.name);
-
if (fout->remoteVersion >= 80300)
{
appendPQExpBuffer(query, "SELECT oprkind, "
"oprcode::pg_catalog.regprocedure, "
"oprleft::pg_catalog.regtype, "
"oprright::pg_catalog.regtype, "
- "oprcom::pg_catalog.regoperator, "
- "oprnegate::pg_catalog.regoperator, "
+ "oprcom, "
+ "oprnegate, "
"oprrest::pg_catalog.regprocedure, "
"oprjoin::pg_catalog.regprocedure, "
"oprcanmerge, oprcanhash "
"oprcode::pg_catalog.regprocedure, "
"oprleft::pg_catalog.regtype, "
"oprright::pg_catalog.regtype, "
- "oprcom::pg_catalog.regoperator, "
- "oprnegate::pg_catalog.regoperator, "
+ "oprcom, "
+ "oprnegate, "
"oprrest::pg_catalog.regprocedure, "
"oprjoin::pg_catalog.regprocedure, "
"(oprlsortop != 0) AS oprcanmerge, "
else
appendPQExpBufferStr(oprid, ", NONE)");
- oprref = convertOperatorReference(fout, oprcom);
+ oprref = getFormattedOperatorName(fout, oprcom);
if (oprref)
{
appendPQExpBuffer(details, ",\n COMMUTATOR = %s", oprref);
free(oprref);
}
- oprref = convertOperatorReference(fout, oprnegate);
+ oprref = getFormattedOperatorName(fout, oprnegate);
if (oprref)
{
appendPQExpBuffer(details, ",\n NEGATOR = %s", oprref);
free(oprregproc);
}
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
appendPQExpBuffer(delq, "DROP OPERATOR %s.%s;\n",
fmtId(oprinfo->dobj.namespace->dobj.name),
oprid->data);
- appendPQExpBuffer(q, "CREATE OPERATOR %s (\n%s\n);\n",
+ appendPQExpBuffer(q, "CREATE OPERATOR %s.%s (\n%s\n);\n",
+ fmtId(oprinfo->dobj.namespace->dobj.name),
oprinfo->dobj.name, details->data);
- appendPQExpBuffer(labelq, "OPERATOR %s", oprid->data);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &oprinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &oprinfo->dobj,
+ "OPERATOR", oprid->data,
+ oprinfo->dobj.namespace->dobj.name);
if (oprinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, oprinfo->dobj.catId, oprinfo->dobj.dumpId,
/* Dump Operator Comments */
if (oprinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "OPERATOR", oprid->data,
oprinfo->dobj.namespace->dobj.name, oprinfo->rolname,
oprinfo->dobj.catId, 0, oprinfo->dobj.dumpId);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(oprid);
destroyPQExpBuffer(details);
}
}
/*
- * Convert an operator cross-reference obtained from pg_operator
+ * getFormattedOperatorName - retrieve the operator name for the
+ * given operator OID (presented in string form).
*
- * Returns an allocated string of what to print, or NULL to print nothing.
+ * Returns an allocated string, or NULL if the given OID is invalid.
* Caller is responsible for free'ing result string.
*
- * The input is a REGOPERATOR display; we have to strip the argument-types
- * part, and add OPERATOR() decoration if the name is schema-qualified.
+ * What we produce has the format "OPERATOR(schema.oprname)". This is only
+ * useful in commands where the operator's argument types can be inferred from
+ * context. We always schema-qualify the name, though. The predecessor to
+ * this code tried to skip the schema qualification if possible, but that led
+ * to wrong results in corner cases, such as if an operator and its negator
+ * are in different schemas.
*/
static char *
-convertOperatorReference(Archive *fout, const char *opr)
+getFormattedOperatorName(Archive *fout, const char *oproid)
{
- char *name;
- char *oname;
- char *ptr;
- bool inquote;
- bool sawdot;
+ OprInfo *oprInfo;
/* In all cases "0" means a null reference */
- if (strcmp(opr, "0") == 0)
+ if (strcmp(oproid, "0") == 0)
return NULL;
- name = pg_strdup(opr);
- /* find non-double-quoted left paren, and check for non-quoted dot */
- inquote = false;
- sawdot = false;
- for (ptr = name; *ptr; ptr++)
+ oprInfo = findOprByOid(atooid(oproid));
+ if (oprInfo == NULL)
{
- if (*ptr == '"')
- inquote = !inquote;
- else if (*ptr == '.' && !inquote)
- sawdot = true;
- else if (*ptr == '(' && !inquote)
- {
- *ptr = '\0';
- break;
- }
+ write_msg(NULL, "WARNING: could not find operator with OID %s\n",
+ oproid);
+ return NULL;
}
- /* If not schema-qualified, don't need to add OPERATOR() */
- if (!sawdot)
- return name;
- oname = psprintf("OPERATOR(%s)", name);
- free(name);
- return oname;
+
+ return psprintf("OPERATOR(%s.%s)",
+ fmtId(oprInfo->dobj.namespace->dobj.name),
+ oprInfo->dobj.name);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
char *qamname;
/* Skip if not to be dumped */
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
qamname = pg_strdup(fmtId(aminfo->dobj.name));
default:
write_msg(NULL, "WARNING: invalid type \"%c\" of access method \"%s\"\n",
aminfo->amtype, qamname);
- pg_free(qamname);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qamname);
return;
}
appendPQExpBuffer(delq, "DROP ACCESS METHOD %s;\n",
qamname);
- appendPQExpBuffer(labelq, "ACCESS METHOD %s",
- qamname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &aminfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &aminfo->dobj,
+ "ACCESS METHOD", qamname, NULL);
if (aminfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, aminfo->dobj.catId, aminfo->dobj.dumpId,
/* Dump Access Method Comments */
if (aminfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "ACCESS METHOD", qamname,
NULL, "",
aminfo->dobj.catId, 0, aminfo->dobj.dumpId);
- pg_free(qamname);
-
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qamname);
}
/*
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
+ PQExpBuffer nameusing;
PGresult *res;
int ntups;
int i_opcintype;
query = createPQExpBuffer();
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
-
- /* Make sure we are in proper schema so regoperator works correctly */
- selectSourceSchema(fout, opcinfo->dobj.namespace->dobj.name);
+ nameusing = createPQExpBuffer();
/* Get additional fields from the pg_opclass row */
if (fout->remoteVersion >= 80300)
/* amname will still be needed after we PQclear res */
amname = pg_strdup(PQgetvalue(res, 0, i_amname));
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
appendPQExpBuffer(delq, "DROP OPERATOR CLASS %s",
- fmtId(opcinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s",
- fmtId(opcinfo->dobj.name));
+ fmtQualifiedDumpable(opcinfo));
appendPQExpBuffer(delq, " USING %s;\n",
fmtId(amname));
/* Build the fixed portion of the CREATE command */
appendPQExpBuffer(q, "CREATE OPERATOR CLASS %s\n ",
- fmtId(opcinfo->dobj.name));
+ fmtQualifiedDumpable(opcinfo));
if (strcmp(opcdefault, "t") == 0)
appendPQExpBufferStr(q, "DEFAULT ");
appendPQExpBuffer(q, "FOR TYPE %s USING %s",
if (strlen(opcfamilyname) > 0)
{
appendPQExpBufferStr(q, " FAMILY ");
- if (strcmp(opcfamilynsp, opcinfo->dobj.namespace->dobj.name) != 0)
- appendPQExpBuffer(q, "%s.", fmtId(opcfamilynsp));
+ appendPQExpBuffer(q, "%s.", fmtId(opcfamilynsp));
appendPQExpBufferStr(q, fmtId(opcfamilyname));
}
appendPQExpBufferStr(q, " AS\n ");
if (strlen(sortfamily) > 0)
{
appendPQExpBufferStr(q, " FOR ORDER BY ");
- if (strcmp(sortfamilynsp, opcinfo->dobj.namespace->dobj.name) != 0)
- appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
+ appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
appendPQExpBufferStr(q, fmtId(sortfamily));
}
appendPQExpBufferStr(q, ";\n");
- appendPQExpBuffer(labelq, "OPERATOR CLASS %s",
- fmtId(opcinfo->dobj.name));
- appendPQExpBuffer(labelq, " USING %s",
+ appendPQExpBufferStr(nameusing, fmtId(opcinfo->dobj.name));
+ appendPQExpBuffer(nameusing, " USING %s",
fmtId(amname));
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &opcinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &opcinfo->dobj,
+ "OPERATOR CLASS", nameusing->data,
+ opcinfo->dobj.namespace->dobj.name);
if (opcinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, opcinfo->dobj.catId, opcinfo->dobj.dumpId,
/* Dump Operator Class Comments */
if (opcinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "OPERATOR CLASS", nameusing->data,
opcinfo->dobj.namespace->dobj.name, opcinfo->rolname,
opcinfo->dobj.catId, 0, opcinfo->dobj.dumpId);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ destroyPQExpBuffer(nameusing);
}
/*
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
+ PQExpBuffer nameusing;
PGresult *res;
PGresult *res_ops;
PGresult *res_procs;
query = createPQExpBuffer();
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
-
- /* Make sure we are in proper schema so regoperator works correctly */
- selectSourceSchema(fout, opfinfo->dobj.namespace->dobj.name);
+ nameusing = createPQExpBuffer();
/*
* Fetch only those opfamily members that are tied directly to the
/* amname will still be needed after we PQclear res */
amname = pg_strdup(PQgetvalue(res, 0, i_amname));
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
appendPQExpBuffer(delq, "DROP OPERATOR FAMILY %s",
- fmtId(opfinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s",
- fmtId(opfinfo->dobj.name));
+ fmtQualifiedDumpable(opfinfo));
appendPQExpBuffer(delq, " USING %s;\n",
fmtId(amname));
/* Build the fixed portion of the CREATE command */
appendPQExpBuffer(q, "CREATE OPERATOR FAMILY %s",
- fmtId(opfinfo->dobj.name));
+ fmtQualifiedDumpable(opfinfo));
appendPQExpBuffer(q, " USING %s;\n",
fmtId(amname));
if (PQntuples(res_ops) > 0 || PQntuples(res_procs) > 0)
{
appendPQExpBuffer(q, "ALTER OPERATOR FAMILY %s",
- fmtId(opfinfo->dobj.name));
+ fmtQualifiedDumpable(opfinfo));
appendPQExpBuffer(q, " USING %s ADD\n ",
fmtId(amname));
if (strlen(sortfamily) > 0)
{
appendPQExpBufferStr(q, " FOR ORDER BY ");
- if (strcmp(sortfamilynsp, opfinfo->dobj.namespace->dobj.name) != 0)
- appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
+ appendPQExpBuffer(q, "%s.", fmtId(sortfamilynsp));
appendPQExpBufferStr(q, fmtId(sortfamily));
}
appendPQExpBufferStr(q, ";\n");
}
- appendPQExpBuffer(labelq, "OPERATOR FAMILY %s",
- fmtId(opfinfo->dobj.name));
- appendPQExpBuffer(labelq, " USING %s",
+ appendPQExpBufferStr(nameusing, fmtId(opfinfo->dobj.name));
+ appendPQExpBuffer(nameusing, " USING %s",
fmtId(amname));
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &opfinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &opfinfo->dobj,
+ "OPERATOR FAMILY", nameusing->data,
+ opfinfo->dobj.namespace->dobj.name);
if (opfinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, opfinfo->dobj.catId, opfinfo->dobj.dumpId,
/* Dump Operator Family Comments */
if (opfinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "OPERATOR FAMILY", nameusing->data,
opfinfo->dobj.namespace->dobj.name, opfinfo->rolname,
opfinfo->dobj.catId, 0, opfinfo->dobj.dumpId);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ destroyPQExpBuffer(nameusing);
}
/*
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
+ char *qcollname;
PGresult *res;
int i_collprovider;
int i_collcollate;
query = createPQExpBuffer();
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, collinfo->dobj.namespace->dobj.name);
+ qcollname = pg_strdup(fmtId(collinfo->dobj.name));
/* Get collation-specific details */
if (fout->remoteVersion >= 100000)
collcollate = PQgetvalue(res, 0, i_collcollate);
collctype = PQgetvalue(res, 0, i_collctype);
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP COLLATION %s",
- fmtId(collinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s;\n",
- fmtId(collinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP COLLATION %s;\n",
+ fmtQualifiedDumpable(collinfo));
appendPQExpBuffer(q, "CREATE COLLATION %s (",
- fmtId(collinfo->dobj.name));
+ fmtQualifiedDumpable(collinfo));
appendPQExpBufferStr(q, "provider = ");
if (collprovider[0] == 'c')
appendPQExpBufferStr(q, ");\n");
- appendPQExpBuffer(labelq, "COLLATION %s", fmtId(collinfo->dobj.name));
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &collinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &collinfo->dobj,
+ "COLLATION", qcollname,
+ collinfo->dobj.namespace->dobj.name);
if (collinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, collinfo->dobj.catId, collinfo->dobj.dumpId,
/* Dump Collation Comments */
if (collinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "COLLATION", qcollname,
collinfo->dobj.namespace->dobj.name, collinfo->rolname,
collinfo->dobj.catId, 0, collinfo->dobj.dumpId);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qcollname);
}
/*
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
+ char *qconvname;
PGresult *res;
int i_conforencoding;
int i_contoencoding;
query = createPQExpBuffer();
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, convinfo->dobj.namespace->dobj.name);
+ qconvname = pg_strdup(fmtId(convinfo->dobj.name));
/* Get conversion-specific details */
appendPQExpBuffer(query, "SELECT "
conproc = PQgetvalue(res, 0, i_conproc);
condefault = (PQgetvalue(res, 0, i_condefault)[0] == 't');
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP CONVERSION %s",
- fmtId(convinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s;\n",
- fmtId(convinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP CONVERSION %s;\n",
+ fmtQualifiedDumpable(convinfo));
appendPQExpBuffer(q, "CREATE %sCONVERSION %s FOR ",
(condefault) ? "DEFAULT " : "",
- fmtId(convinfo->dobj.name));
+ fmtQualifiedDumpable(convinfo));
appendStringLiteralAH(q, conforencoding, fout);
appendPQExpBufferStr(q, " TO ");
appendStringLiteralAH(q, contoencoding, fout);
/* regproc output is already sufficiently quoted */
appendPQExpBuffer(q, " FROM %s;\n", conproc);
- appendPQExpBuffer(labelq, "CONVERSION %s", fmtId(convinfo->dobj.name));
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &convinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &convinfo->dobj,
+ "CONVERSION", qconvname,
+ convinfo->dobj.namespace->dobj.name);
if (convinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, convinfo->dobj.catId, convinfo->dobj.dumpId,
/* Dump Conversion Comments */
if (convinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "CONVERSION", qconvname,
convinfo->dobj.namespace->dobj.name, convinfo->rolname,
convinfo->dobj.catId, 0, convinfo->dobj.dumpId);
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qconvname);
}
/*
PQExpBuffer query;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
PQExpBuffer details;
char *aggsig; /* identity signature */
char *aggfullsig = NULL; /* full signature */
query = createPQExpBuffer();
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
details = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, agginfo->aggfn.dobj.namespace->dobj.name);
-
/* Get aggregate-specific details */
if (fout->remoteVersion >= 110000)
{
"aggminvtransfn, aggmfinalfn, aggmtranstype::pg_catalog.regtype, "
"aggfinalextra, aggmfinalextra, "
"aggfinalmodify, aggmfinalmodify, "
- "aggsortop::pg_catalog.regoperator, "
+ "aggsortop, "
"aggkind, "
"aggtransspace, agginitval, "
"aggmtransspace, aggminitval, "
"aggminvtransfn, aggmfinalfn, aggmtranstype::pg_catalog.regtype, "
"aggfinalextra, aggmfinalextra, "
"'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
- "aggsortop::pg_catalog.regoperator, "
+ "aggsortop, "
"aggkind, "
"aggtransspace, agginitval, "
"aggmtransspace, aggminitval, "
"aggmfinalfn, aggmtranstype::pg_catalog.regtype, "
"aggfinalextra, aggmfinalextra, "
"'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
- "aggsortop::pg_catalog.regoperator, "
+ "aggsortop, "
"aggkind, "
"aggtransspace, agginitval, "
"aggmtransspace, aggminitval, "
"0 AS aggmtranstype, false AS aggfinalextra, "
"false AS aggmfinalextra, "
"'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
- "aggsortop::pg_catalog.regoperator, "
+ "aggsortop, "
"'n' AS aggkind, "
"0 AS aggtransspace, agginitval, "
"0 AS aggmtransspace, NULL AS aggminitval, "
"0 AS aggmtranstype, false AS aggfinalextra, "
"false AS aggmfinalextra, "
"'0' AS aggfinalmodify, '0' AS aggmfinalmodify, "
- "aggsortop::pg_catalog.regoperator, "
+ "aggsortop, "
"'n' AS aggkind, "
"0 AS aggtransspace, agginitval, "
"0 AS aggmtransspace, NULL AS aggminitval, "
}
}
- aggsortconvop = convertOperatorReference(fout, aggsortop);
+ aggsortconvop = getFormattedOperatorName(fout, aggsortop);
if (aggsortconvop)
{
appendPQExpBuffer(details, ",\n SORTOP = %s",
agginfo->aggfn.dobj.name);
}
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
appendPQExpBuffer(delq, "DROP AGGREGATE %s.%s;\n",
fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
aggsig);
- appendPQExpBuffer(q, "CREATE AGGREGATE %s (\n%s\n);\n",
+ appendPQExpBuffer(q, "CREATE AGGREGATE %s.%s (\n%s\n);\n",
+ fmtId(agginfo->aggfn.dobj.namespace->dobj.name),
aggfullsig ? aggfullsig : aggsig, details->data);
- appendPQExpBuffer(labelq, "AGGREGATE %s", aggsig);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &agginfo->aggfn.dobj, labelq->data);
+ binary_upgrade_extension_member(q, &agginfo->aggfn.dobj,
+ "AGGREGATE", aggsig,
+ agginfo->aggfn.dobj.namespace->dobj.name);
if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, agginfo->aggfn.dobj.catId,
/* Dump Aggregate Comments */
if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "AGGREGATE", aggsig,
agginfo->aggfn.dobj.namespace->dobj.name,
agginfo->aggfn.rolname,
agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_SECLABEL)
- dumpSecLabel(fout, labelq->data,
+ dumpSecLabel(fout, "AGGREGATE", aggsig,
agginfo->aggfn.dobj.namespace->dobj.name,
agginfo->aggfn.rolname,
agginfo->aggfn.dobj.catId, 0, agginfo->aggfn.dobj.dumpId);
if (agginfo->aggfn.dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, agginfo->aggfn.dobj.catId, agginfo->aggfn.dobj.dumpId,
- "FUNCTION",
- aggsig, NULL, labelq->data,
+ "FUNCTION", aggsig, NULL,
agginfo->aggfn.dobj.namespace->dobj.name,
agginfo->aggfn.rolname, agginfo->aggfn.proacl,
agginfo->aggfn.rproacl,
destroyPQExpBuffer(query);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(details);
}
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
+ char *qprsname;
/* Skip if not to be dumped */
if (!prsinfo->dobj.dump || dopt->dataOnly)
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, prsinfo->dobj.namespace->dobj.name);
+ qprsname = pg_strdup(fmtId(prsinfo->dobj.name));
appendPQExpBuffer(q, "CREATE TEXT SEARCH PARSER %s (\n",
- fmtId(prsinfo->dobj.name));
+ fmtQualifiedDumpable(prsinfo));
appendPQExpBuffer(q, " START = %s,\n",
convertTSFunction(fout, prsinfo->prsstart));
appendPQExpBuffer(q, " LEXTYPES = %s );\n",
convertTSFunction(fout, prsinfo->prslextype));
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP TEXT SEARCH PARSER %s",
- fmtId(prsinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s;\n",
- fmtId(prsinfo->dobj.name));
-
- appendPQExpBuffer(labelq, "TEXT SEARCH PARSER %s",
- fmtId(prsinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP TEXT SEARCH PARSER %s;\n",
+ fmtQualifiedDumpable(prsinfo));
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &prsinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &prsinfo->dobj,
+ "TEXT SEARCH PARSER", qprsname,
+ prsinfo->dobj.namespace->dobj.name);
if (prsinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, prsinfo->dobj.catId, prsinfo->dobj.dumpId,
/* Dump Parser Comments */
if (prsinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TEXT SEARCH PARSER", qprsname,
prsinfo->dobj.namespace->dobj.name, "",
prsinfo->dobj.catId, 0, prsinfo->dobj.dumpId);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qprsname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
PQExpBuffer query;
+ char *qdictname;
PGresult *res;
char *nspname;
char *tmplname;
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
query = createPQExpBuffer();
+ qdictname = pg_strdup(fmtId(dictinfo->dobj.name));
+
/* Fetch name and namespace of the dictionary's template */
- selectSourceSchema(fout, "pg_catalog");
appendPQExpBuffer(query, "SELECT nspname, tmplname "
"FROM pg_ts_template p, pg_namespace n "
"WHERE p.oid = '%u' AND n.oid = tmplnamespace",
nspname = PQgetvalue(res, 0, 0);
tmplname = PQgetvalue(res, 0, 1);
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, dictinfo->dobj.namespace->dobj.name);
-
appendPQExpBuffer(q, "CREATE TEXT SEARCH DICTIONARY %s (\n",
- fmtId(dictinfo->dobj.name));
+ fmtQualifiedDumpable(dictinfo));
appendPQExpBufferStr(q, " TEMPLATE = ");
- if (strcmp(nspname, dictinfo->dobj.namespace->dobj.name) != 0)
- appendPQExpBuffer(q, "%s.", fmtId(nspname));
+ appendPQExpBuffer(q, "%s.", fmtId(nspname));
appendPQExpBufferStr(q, fmtId(tmplname));
PQclear(res);
appendPQExpBufferStr(q, " );\n");
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP TEXT SEARCH DICTIONARY %s",
- fmtId(dictinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s;\n",
- fmtId(dictinfo->dobj.name));
-
- appendPQExpBuffer(labelq, "TEXT SEARCH DICTIONARY %s",
- fmtId(dictinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP TEXT SEARCH DICTIONARY %s;\n",
+ fmtQualifiedDumpable(dictinfo));
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &dictinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &dictinfo->dobj,
+ "TEXT SEARCH DICTIONARY", qdictname,
+ dictinfo->dobj.namespace->dobj.name);
if (dictinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, dictinfo->dobj.catId, dictinfo->dobj.dumpId,
/* Dump Dictionary Comments */
if (dictinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TEXT SEARCH DICTIONARY", qdictname,
dictinfo->dobj.namespace->dobj.name, dictinfo->rolname,
dictinfo->dobj.catId, 0, dictinfo->dobj.dumpId);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qdictname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
+ char *qtmplname;
/* Skip if not to be dumped */
if (!tmplinfo->dobj.dump || dopt->dataOnly)
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, tmplinfo->dobj.namespace->dobj.name);
+ qtmplname = pg_strdup(fmtId(tmplinfo->dobj.name));
appendPQExpBuffer(q, "CREATE TEXT SEARCH TEMPLATE %s (\n",
- fmtId(tmplinfo->dobj.name));
+ fmtQualifiedDumpable(tmplinfo));
if (tmplinfo->tmplinit != InvalidOid)
appendPQExpBuffer(q, " INIT = %s,\n",
appendPQExpBuffer(q, " LEXIZE = %s );\n",
convertTSFunction(fout, tmplinfo->tmpllexize));
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP TEXT SEARCH TEMPLATE %s",
- fmtId(tmplinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s;\n",
- fmtId(tmplinfo->dobj.name));
-
- appendPQExpBuffer(labelq, "TEXT SEARCH TEMPLATE %s",
- fmtId(tmplinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP TEXT SEARCH TEMPLATE %s;\n",
+ fmtQualifiedDumpable(tmplinfo));
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &tmplinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &tmplinfo->dobj,
+ "TEXT SEARCH TEMPLATE", qtmplname,
+ tmplinfo->dobj.namespace->dobj.name);
if (tmplinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, tmplinfo->dobj.catId, tmplinfo->dobj.dumpId,
/* Dump Template Comments */
if (tmplinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TEXT SEARCH TEMPLATE", qtmplname,
tmplinfo->dobj.namespace->dobj.name, "",
tmplinfo->dobj.catId, 0, tmplinfo->dobj.dumpId);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
+ free(qtmplname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
PQExpBuffer query;
+ char *qcfgname;
PGresult *res;
char *nspname;
char *prsname;
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
query = createPQExpBuffer();
+ qcfgname = pg_strdup(fmtId(cfginfo->dobj.name));
+
/* Fetch name and namespace of the config's parser */
- selectSourceSchema(fout, "pg_catalog");
appendPQExpBuffer(query, "SELECT nspname, prsname "
"FROM pg_ts_parser p, pg_namespace n "
"WHERE p.oid = '%u' AND n.oid = prsnamespace",
nspname = PQgetvalue(res, 0, 0);
prsname = PQgetvalue(res, 0, 1);
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, cfginfo->dobj.namespace->dobj.name);
-
appendPQExpBuffer(q, "CREATE TEXT SEARCH CONFIGURATION %s (\n",
- fmtId(cfginfo->dobj.name));
+ fmtQualifiedDumpable(cfginfo));
- appendPQExpBufferStr(q, " PARSER = ");
- if (strcmp(nspname, cfginfo->dobj.namespace->dobj.name) != 0)
- appendPQExpBuffer(q, "%s.", fmtId(nspname));
+ appendPQExpBuffer(q, " PARSER = %s.", fmtId(nspname));
appendPQExpBuffer(q, "%s );\n", fmtId(prsname));
PQclear(res);
if (i > 0)
appendPQExpBufferStr(q, ";\n");
appendPQExpBuffer(q, "\nALTER TEXT SEARCH CONFIGURATION %s\n",
- fmtId(cfginfo->dobj.name));
+ fmtQualifiedDumpable(cfginfo));
/* tokenname needs quoting, dictname does NOT */
appendPQExpBuffer(q, " ADD MAPPING FOR %s WITH %s",
fmtId(tokenname), dictname);
PQclear(res);
- /*
- * DROP must be fully qualified in case same name appears in pg_catalog
- */
- appendPQExpBuffer(delq, "DROP TEXT SEARCH CONFIGURATION %s",
- fmtId(cfginfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, ".%s;\n",
- fmtId(cfginfo->dobj.name));
-
- appendPQExpBuffer(labelq, "TEXT SEARCH CONFIGURATION %s",
- fmtId(cfginfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP TEXT SEARCH CONFIGURATION %s;\n",
+ fmtQualifiedDumpable(cfginfo));
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &cfginfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &cfginfo->dobj,
+ "TEXT SEARCH CONFIGURATION", qcfgname,
+ cfginfo->dobj.namespace->dobj.name);
if (cfginfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, cfginfo->dobj.catId, cfginfo->dobj.dumpId,
/* Dump Configuration Comments */
if (cfginfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "TEXT SEARCH CONFIGURATION", qcfgname,
cfginfo->dobj.namespace->dobj.name, cfginfo->rolname,
cfginfo->dobj.catId, 0, cfginfo->dobj.dumpId);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
+ free(qcfgname);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
char *qfdwname;
/* Skip if not to be dumped */
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
qfdwname = pg_strdup(fmtId(fdwinfo->dobj.name));
appendPQExpBuffer(delq, "DROP FOREIGN DATA WRAPPER %s;\n",
qfdwname);
- appendPQExpBuffer(labelq, "FOREIGN DATA WRAPPER %s",
- qfdwname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &fdwinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &fdwinfo->dobj,
+ "FOREIGN DATA WRAPPER", qfdwname,
+ NULL);
if (fdwinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
/* Dump Foreign Data Wrapper Comments */
if (fdwinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "FOREIGN DATA WRAPPER", qfdwname,
NULL, fdwinfo->rolname,
fdwinfo->dobj.catId, 0, fdwinfo->dobj.dumpId);
/* Handle the ACL */
if (fdwinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, fdwinfo->dobj.catId, fdwinfo->dobj.dumpId,
- "FOREIGN DATA WRAPPER",
- qfdwname, NULL, labelq->data,
+ "FOREIGN DATA WRAPPER", qfdwname, NULL,
NULL, fdwinfo->rolname,
fdwinfo->fdwacl, fdwinfo->rfdwacl,
fdwinfo->initfdwacl, fdwinfo->initrfdwacl);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
}
/*
DumpOptions *dopt = fout->dopt;
PQExpBuffer q;
PQExpBuffer delq;
- PQExpBuffer labelq;
PQExpBuffer query;
PGresult *res;
char *qsrvname;
q = createPQExpBuffer();
delq = createPQExpBuffer();
- labelq = createPQExpBuffer();
query = createPQExpBuffer();
qsrvname = pg_strdup(fmtId(srvinfo->dobj.name));
/* look up the foreign-data wrapper */
- selectSourceSchema(fout, "pg_catalog");
appendPQExpBuffer(query, "SELECT fdwname "
"FROM pg_foreign_data_wrapper w "
"WHERE w.oid = '%u'",
appendPQExpBuffer(delq, "DROP SERVER %s;\n",
qsrvname);
- appendPQExpBuffer(labelq, "SERVER %s", qsrvname);
-
if (dopt->binary_upgrade)
- binary_upgrade_extension_member(q, &srvinfo->dobj, labelq->data);
+ binary_upgrade_extension_member(q, &srvinfo->dobj,
+ "SERVER", qsrvname, NULL);
if (srvinfo->dobj.dump & DUMP_COMPONENT_DEFINITION)
ArchiveEntry(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
/* Dump Foreign Server Comments */
if (srvinfo->dobj.dump & DUMP_COMPONENT_COMMENT)
- dumpComment(fout, labelq->data,
+ dumpComment(fout, "SERVER", qsrvname,
NULL, srvinfo->rolname,
srvinfo->dobj.catId, 0, srvinfo->dobj.dumpId);
/* Handle the ACL */
if (srvinfo->dobj.dump & DUMP_COMPONENT_ACL)
dumpACL(fout, srvinfo->dobj.catId, srvinfo->dobj.dumpId,
- "FOREIGN SERVER",
- qsrvname, NULL, labelq->data,
+ "FOREIGN SERVER", qsrvname, NULL,
NULL, srvinfo->rolname,
srvinfo->srvacl, srvinfo->rsrvacl,
srvinfo->initsrvacl, srvinfo->initrsrvacl);
destroyPQExpBuffer(q);
destroyPQExpBuffer(delq);
- destroyPQExpBuffer(labelq);
destroyPQExpBuffer(query);
}
* OPTIONS clause. A possible alternative is to skip such mappings
* altogether, but it's not clear that that's an improvement.
*/
- selectSourceSchema(fout, "pg_catalog");
-
appendPQExpBuffer(query,
"SELECT usename, "
"array_to_string(ARRAY("
* FOREIGN DATA WRAPPER, SERVER, or LARGE OBJECT.
* 'name' is the formatted name of the object. Must be quoted etc. already.
* 'subname' is the formatted name of the sub-object, if any. Must be quoted.
- * 'tag' is the tag for the archive entry (should be the same tag as would be
- * used for comments etc; for example "TABLE foo").
+ * (Currently we assume that subname is only provided for table columns.)
* 'nspname' is the namespace the object is in (NULL if none).
* 'owner' is the owner, NULL if there is no owner (for languages).
* 'acls' contains the ACL string of the object from the appropriate system
static void
dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
const char *type, const char *name, const char *subname,
- const char *tag, const char *nspname, const char *owner,
+ const char *nspname, const char *owner,
const char *acls, const char *racls,
const char *initacls, const char *initracls)
{
if (strlen(initacls) != 0 || strlen(initracls) != 0)
{
appendPQExpBuffer(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(true);\n");
- if (!buildACLCommands(name, subname, type, initacls, initracls, owner,
+ if (!buildACLCommands(name, subname, nspname, type,
+ initacls, initracls, owner,
"", fout->remoteVersion, sql))
exit_horribly(NULL,
"could not parse initial GRANT ACL list (%s) or initial REVOKE ACL list (%s) for object \"%s\" (%s)\n",
appendPQExpBuffer(sql, "SELECT pg_catalog.binary_upgrade_set_record_init_privs(false);\n");
}
- if (!buildACLCommands(name, subname, type, acls, racls, owner,
+ if (!buildACLCommands(name, subname, nspname, type,
+ acls, racls, owner,
"", fout->remoteVersion, sql))
exit_horribly(NULL,
"could not parse GRANT ACL list (%s) or REVOKE ACL list (%s) for object \"%s\" (%s)\n",
acls, racls, name, type);
if (sql->len > 0)
+ {
+ PQExpBuffer tag = createPQExpBuffer();
+
+ if (subname)
+ appendPQExpBuffer(tag, "COLUMN %s.%s", name, subname);
+ else
+ appendPQExpBuffer(tag, "%s %s", type, name);
+
ArchiveEntry(fout, nilCatalogId, createDumpId(),
- tag, nspname,
+ tag->data, nspname,
NULL,
owner ? owner : "",
false, "ACL", SECTION_NONE,
sql->data, "", NULL,
&(objDumpId), 1,
NULL, NULL);
+ destroyPQExpBuffer(tag);
+ }
destroyPQExpBuffer(sql);
}
* dumpSecLabel
*
* This routine is used to dump any security labels associated with the
- * object handed to this routine. The routine takes a constant character
- * string for the target part of the security-label command, plus
+ * object handed to this routine. The routine takes the object type
+ * and object name (ready to print, except for schema decoration), plus
* the namespace and owner of the object (for labeling the ArchiveEntry),
* plus catalog ID and subid which are the lookup key for pg_seclabel,
* plus the dump ID for the object (for setting a dependency).
* calling ArchiveEntry() for the specified object.
*/
static void
-dumpSecLabel(Archive *fout, const char *target,
+dumpSecLabel(Archive *fout, const char *type, const char *name,
const char *namespace, const char *owner,
CatalogId catalogId, int subid, DumpId dumpId)
{
return;
/* Security labels are schema not data ... except blob labels are data */
- if (strncmp(target, "LARGE OBJECT ", 13) != 0)
+ if (strcmp(type, "LARGE OBJECT") != 0)
{
if (dopt->dataOnly)
return;
continue;
appendPQExpBuffer(query,
- "SECURITY LABEL FOR %s ON %s IS ",
- fmtId(labels[i].provider), target);
+ "SECURITY LABEL FOR %s ON %s ",
+ fmtId(labels[i].provider), type);
+ if (namespace && *namespace)
+ appendPQExpBuffer(query, "%s.", fmtId(namespace));
+ appendPQExpBuffer(query, "%s IS ", name);
appendStringLiteralAH(query, labels[i].label, fout);
appendPQExpBufferStr(query, ";\n");
}
if (query->len > 0)
{
+ PQExpBuffer tag = createPQExpBuffer();
+
+ appendPQExpBuffer(tag, "%s %s", type, name);
ArchiveEntry(fout, nilCatalogId, createDumpId(),
- target, namespace, NULL, owner,
+ tag->data, namespace, NULL, owner,
false, "SECURITY LABEL", SECTION_NONE,
query->data, "", NULL,
&(dumpId), 1,
NULL, NULL);
+ destroyPQExpBuffer(tag);
}
+
destroyPQExpBuffer(query);
}
if (objsubid == 0)
{
appendPQExpBuffer(target, "%s %s", reltypename,
- fmtId(tbinfo->dobj.name));
+ fmtQualifiedDumpable(tbinfo));
}
else
{
colname = getAttrName(objsubid, tbinfo);
- /* first fmtId result must be consumed before calling it again */
- appendPQExpBuffer(target, "COLUMN %s", fmtId(tbinfo->dobj.name));
+ /* first fmtXXX result must be consumed before calling again */
+ appendPQExpBuffer(target, "COLUMN %s",
+ fmtQualifiedDumpable(tbinfo));
appendPQExpBuffer(target, ".%s", fmtId(colname));
}
appendPQExpBuffer(query, "SECURITY LABEL FOR %s ON %s IS ",
{
const char *objtype =
(tbinfo->relkind == RELKIND_SEQUENCE) ? "SEQUENCE" : "TABLE";
- char *acltag = psprintf("%s %s", objtype, namecopy);
dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
- objtype, namecopy, NULL, acltag,
+ objtype, namecopy, NULL,
tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
tbinfo->relacl, tbinfo->rrelacl,
tbinfo->initrelacl, tbinfo->initrrelacl);
- free(acltag);
}
/*
char *initattacl = PQgetvalue(res, i, 3);
char *initrattacl = PQgetvalue(res, i, 4);
char *attnamecopy;
- char *acltag;
attnamecopy = pg_strdup(fmtId(attname));
- acltag = psprintf("COLUMN %s.%s", namecopy, attnamecopy);
/* Column's GRANT type is always TABLE */
- dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId, "TABLE",
- namecopy, attnamecopy, acltag,
+ dumpACL(fout, tbinfo->dobj.catId, tbinfo->dobj.dumpId,
+ "TABLE", namecopy, attnamecopy,
tbinfo->dobj.namespace->dobj.name, tbinfo->rolname,
attacl, rattacl, initattacl, initrattacl);
free(attnamecopy);
- free(acltag);
}
PQclear(res);
destroyPQExpBuffer(query);
coll = findCollationByOid(tbinfo->attcollation[j]);
if (coll)
- {
- /* always schema-qualify, don't try to be smart */
- appendPQExpBuffer(result, " COLLATE %s.",
- fmtId(coll->dobj.namespace->dobj.name));
- appendPQExpBufferStr(result, fmtId(coll->dobj.name));
- }
+ appendPQExpBuffer(result, " COLLATE %s",
+ fmtQualifiedDumpable(coll));
}
appendPQExpBuffer(result, " AS %s", fmtId(tbinfo->attnames[j]));
DumpOptions *dopt = fout->dopt;
PQExpBuffer q = createPQExpBuffer();
PQExpBuffer delq = createPQExpBuffer();
- PQExpBuffer labelq = createPQExpBuffer();
+ char *qrelname;
+ char *qualrelname;
int numParents;
TableInfo **parents;
int actual_atts; /* number of attrs in this CREATE statement */
int j,
k;
- /* Make sure we are in proper schema */
- selectSourceSchema(fout, tbinfo->dobj.namespace->dobj.name);
+ qrelname = pg_strdup(fmtId(tbinfo->dobj.name));
+ qualrelname = pg_strdup(fmtQualifiedDumpable(tbinfo));
if (dopt->binary_upgrade)
binary_upgrade_set_type_oids_by_rel_oid(fout, q,
reltypename = "VIEW";
- /*
- * DROP must be fully qualified in case same name appears in
- * pg_catalog
- */
- appendPQExpBuffer(delq, "DROP VIEW %s.",
- fmtId(tbinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- fmtId(tbinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP VIEW %s;\n", qualrelname);
if (dopt->binary_upgrade)
binary_upgrade_set_pg_class_oids(fout, q,
tbinfo->dobj.catId.oid, false);
- appendPQExpBuffer(q, "CREATE VIEW %s", fmtId(tbinfo->dobj.name));
+ appendPQExpBuffer(q, "CREATE VIEW %s", qualrelname);
+
if (tbinfo->dummy_view)
result = createDummyViewAsClause(fout, tbinfo);
else
if (tbinfo->checkoption != NULL && !tbinfo->dummy_view)
appendPQExpBuffer(q, "\n WITH %s CHECK OPTION", tbinfo->checkoption);
appendPQExpBufferStr(q, ";\n");
-
- appendPQExpBuffer(labelq, "VIEW %s",
- fmtId(tbinfo->dobj.name));
}
else
{
numParents = tbinfo->numParents;
parents = tbinfo->parents;
- /*
- * DROP must be fully qualified in case same name appears in
- * pg_catalog
- */
- appendPQExpBuffer(delq, "DROP %s %s.", reltypename,
- fmtId(tbinfo->dobj.namespace->dobj.name));
- appendPQExpBuffer(delq, "%s;\n",
- fmtId(tbinfo->dobj.name));
-
- appendPQExpBuffer(labelq, "%s %s", reltypename,
- fmtId(tbinfo->dobj.name));
+ appendPQExpBuffer(delq, "DROP %s %s;\n", reltypename, qualrelname);
if (dopt->binary_upgrade)
binary_upgrade_set_pg_class_oids(fout, q,
tbinfo->relpersistence == RELPERSISTENCE_UNLOGGED ?
"UNLOGGED " : "",
reltypename,
- fmtId(tbinfo->dobj.name));
+ qualrelname);
/*
* Attach to type, if reloftype; except in case of a binary upgrade,
exit_horribly(NULL, "invalid number of parents %d for table \"%s\"\n",
tbinfo->numParents, tbinfo->dobj.name);
- appendPQExpBuffer(q, " PARTITION OF ");
- if (parentRel->dobj.namespace != tbinfo->dobj.namespace)
- appendPQExpBuffer(q, "%s.",
- fmtId(parentRel->dobj.namespace->dobj.name));
- appendPQExpBufferStr(q, fmtId(parentRel->dobj.name));
+ appendPQExpBuffer(q, " PARTITION OF %s",
+ fmtQualifiedDumpable(parentRel));
}
if (tbinfo->relkind != RELKIND_MATVIEW)
coll = findCollationByOid(tbinfo->attcollation[j]);
if (coll)
- {
- /* always schema-qualify, don't try to be smart */
- appendPQExpBuffer(q, " COLLATE %s.",
- fmtId(coll->dobj.namespace->dobj.name));
- appendPQExpBufferStr(q, fmtId(coll->dobj.name));
- }
+ appendPQExpBuffer(q, " COLLATE %s",
+ fmtQualifiedDumpable(coll));
}
if (has_default)
if (k > 0)
appendPQExpBufferStr(q, ", ");
- if (parentRel->dobj.namespace != tbinfo->dobj.namespace)
- appendPQExpBuffer(q, "%s.",
- fmtId(parentRel->dobj.namespace->dobj.name));
- appendPQExpBufferStr(q, fmtId(parentRel->dobj.name));
+ appendPQExpBufferStr(q, fmtQualifiedDumpable(parentRel));
}
appendPQExpBufferChar(q, ')');
}
tbinfo->attalign[j]);
appendStringLiteralAH(q, tbinfo->attnames[j], fout);
appendPQExpBufferStr(q, "\n AND attrelid = ");
- appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
+ appendStringLiteralAH(q, qualrelname, fout);
appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
if (tbinfo->relkind == RELKIND_RELATION ||
tbinfo->relkind == RELKIND_PARTITIONED_TABLE)
appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
- fmtId(tbinfo->dobj.name));
+ qualrelname);
else
appendPQExpBuffer(q, "ALTER FOREIGN TABLE ONLY %s ",
- fmtId(tbinfo->dobj.name));
+ qualrelname);
appendPQExpBuffer(q, "DROP COLUMN %s;\n",
fmtId(tbinfo->attnames[j]));
}
"WHERE attname = ");
appendStringLiteralAH(q, tbinfo->attnames[j], fout);
appendPQExpBufferStr(q, "\n AND attrelid = ");
- appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
+ appendStringLiteralAH(q, qualrelname, fout);
appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
}
}
appendPQExpBufferStr(q, "\n-- For binary upgrade, set up inherited constraint.\n");
appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
- fmtId(tbinfo->dobj.name));
+ qualrelname);
appendPQExpBuffer(q, " ADD CONSTRAINT %s ",
fmtId(constr->dobj.name));
appendPQExpBuffer(q, "%s;\n", constr->condef);
"WHERE contype = 'c' AND conname = ");
appendStringLiteralAH(q, constr->dobj.name, fout);
appendPQExpBufferStr(q, "\n AND conrelid = ");
- appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
+ appendStringLiteralAH(q, qualrelname, fout);
appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
}
for (k = 0; k < numParents; k++)
{
TableInfo *parentRel = parents[k];
- PQExpBuffer parentname = createPQExpBuffer();
-
- /* Schema-qualify the parent table, if necessary */
- if (parentRel->dobj.namespace != tbinfo->dobj.namespace)
- appendPQExpBuffer(parentname, "%s.",
- fmtId(parentRel->dobj.namespace->dobj.name));
-
- appendPQExpBuffer(parentname, "%s",
- fmtId(parentRel->dobj.name));
/* In the partitioning case, we alter the parent */
if (tbinfo->ispartition)
appendPQExpBuffer(q,
"ALTER TABLE ONLY %s ATTACH PARTITION ",
- parentname->data);
+ fmtQualifiedDumpable(parentRel));
else
appendPQExpBuffer(q, "ALTER TABLE ONLY %s INHERIT ",
- fmtId(tbinfo->dobj.name));
+ qualrelname);
/* Partition needs specifying the bounds */
if (tbinfo->ispartition)
appendPQExpBuffer(q, "%s %s;\n",
- fmtId(tbinfo->dobj.name),
+ qualrelname,
tbinfo->partbound);
else
- appendPQExpBuffer(q, "%s;\n", parentname->data);
-
- destroyPQExpBuffer(parentname);
+ appendPQExpBuffer(q, "%s;\n",
+ fmtQualifiedDumpable(parentRel));
}
}
{
appendPQExpBufferStr(q, "\n-- For binary upgrade, set up typed tables this way.\n");
appendPQExpBuffer(q, "ALTER TABLE ONLY %s OF %s;\n",
- fmtId(tbinfo->dobj.name),
+ qualrelname,
tbinfo->reloftype);
}
}
"SET relfrozenxid = '%u', relminmxid = '%u'\n"
"WHERE oid = ",
tbinfo->frozenxid, tbinfo->minmxid);
- appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
+ appendStringLiteralAH(q, qualrelname, fout);
appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
if (tbinfo->toast_oid)
appendPQExpBufferStr(q, "UPDATE pg_catalog.pg_class\n"
"SET relispopulated = 't'\n"
"WHERE oid = ");
- appendStringLiteralAH(q, fmtId(tbinfo->dobj.name), fout);
+ appendStringLiteralAH(q, qualrelname, fout);
appendPQExpBufferStr(q, "::pg_catalog.regclass;\n");
}
tbinfo->notnull[j] && !tbinfo->inhNotNull[j])
{
appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
- fmtId(tbinfo->dobj.name));
+ qualrelname);
appendPQExpBuffer(q, "ALTER COLUMN %s SET NOT NULL;\n",
fmtId(tbinfo->attnames[j]));
}
if (tbinfo->attstattarget[j] >= 0)
{
appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
- fmtId(tbinfo->dobj.name));
+ qualrelname);
appendPQExpBuffer(q, "ALTER COLUMN %s ",
fmtId(tbinfo->attnames[j]));
appendPQExpBuffer(q, "SET STATISTICS %d;\n",
if (storage != NULL)
{
appendPQExpBuffer(q, "ALTER TABLE ONLY %s ",
-
projects / users / heikki / postgres.git / commitdiff