Rename pg_dump.c TypeInfo variable tinfo to tyinfo, for clarity.
This commit is contained in:
Bruce Momjian
parent
cfc5008a51
commit
b683908064
|
|
@ -12,7 +12,7 @@
|
|||
* by PostgreSQL
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.559 2009/12/22 23:27:41 petere Exp $
|
||||
* $PostgreSQL: pgsql/src/bin/pg_dump/pg_dump.c,v 1.560 2009/12/23 04:10:50 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
|
|
@ -131,12 +131,12 @@ static int findComments(Archive *fout, Oid classoid, Oid objoid,
|
|||
static int collectComments(Archive *fout, CommentItem **items);
|
||||
static void dumpDumpableObject(Archive *fout, DumpableObject *dobj);
|
||||
static void dumpNamespace(Archive *fout, NamespaceInfo *nspinfo);
|
||||
static void dumpType(Archive *fout, TypeInfo *tinfo);
|
||||
static void dumpBaseType(Archive *fout, TypeInfo *tinfo);
|
||||
static void dumpEnumType(Archive *fout, TypeInfo *tinfo);
|
||||
static void dumpDomain(Archive *fout, TypeInfo *tinfo);
|
||||
static void dumpCompositeType(Archive *fout, TypeInfo *tinfo);
|
||||
static void dumpCompositeTypeColComments(Archive *fout, TypeInfo *tinfo);
|
||||
static void dumpType(Archive *fout, TypeInfo *tyinfo);
|
||||
static void dumpBaseType(Archive *fout, TypeInfo *tyinfo);
|
||||
static void dumpEnumType(Archive *fout, TypeInfo *tyinfo);
|
||||
static void dumpDomain(Archive *fout, TypeInfo *tyinfo);
|
||||
static void dumpCompositeType(Archive *fout, TypeInfo *tyinfo);
|
||||
static void dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo);
|
||||
static void dumpShellType(Archive *fout, ShellTypeInfo *stinfo);
|
||||
static void dumpProcLang(Archive *fout, ProcLangInfo *plang);
|
||||
static void dumpFunc(Archive *fout, FuncInfo *finfo);
|
||||
|
|
@ -172,7 +172,7 @@ static void dumpACL(Archive *fout, CatalogId objCatId, DumpId objDumpId,
|
|||
const char *acls);
|
||||
|
||||
static void getDependencies(void);
|
||||
static void getDomainConstraints(TypeInfo *tinfo);
|
||||
static void getDomainConstraints(TypeInfo *tyinfo);
|
||||
static void getTableData(TableInfo *tblinfo, int numTables, bool oids);
|
||||
static void getTableDataFKConstraints(void);
|
||||
static char *format_function_arguments(FuncInfo *finfo, char *funcargs);
|
||||
|
|
@ -1023,33 +1023,33 @@ selectDumpableTable(TableInfo *tbinfo)
|
|||
* first to ensure the objType change is applied regardless of namespace etc.
|
||||
*/
|
||||
static void
|
||||
selectDumpableType(TypeInfo *tinfo)
|
||||
selectDumpableType(TypeInfo *tyinfo)
|
||||
{
|
||||
/* skip complex types, except for standalone composite types */
|
||||
if (OidIsValid(tinfo->typrelid) &&
|
||||
tinfo->typrelkind != RELKIND_COMPOSITE_TYPE)
|
||||
if (OidIsValid(tyinfo->typrelid) &&
|
||||
tyinfo->typrelkind != RELKIND_COMPOSITE_TYPE)
|
||||
{
|
||||
tinfo->dobj.dump = false;
|
||||
tinfo->dobj.objType = DO_DUMMY_TYPE;
|
||||
tyinfo->dobj.dump = false;
|
||||
tyinfo->dobj.objType = DO_DUMMY_TYPE;
|
||||
}
|
||||
|
||||
/* skip auto-generated array types */
|
||||
else if (tinfo->isArray)
|
||||
else if (tyinfo->isArray)
|
||||
{
|
||||
tinfo->dobj.dump = false;
|
||||
tinfo->dobj.objType = DO_DUMMY_TYPE;
|
||||
tyinfo->dobj.dump = false;
|
||||
tyinfo->dobj.objType = DO_DUMMY_TYPE;
|
||||
}
|
||||
|
||||
/* dump only types in dumpable namespaces */
|
||||
else if (!tinfo->dobj.namespace->dobj.dump)
|
||||
tinfo->dobj.dump = false;
|
||||
else if (!tyinfo->dobj.namespace->dobj.dump)
|
||||
tyinfo->dobj.dump = false;
|
||||
|
||||
/* skip undefined placeholder types */
|
||||
else if (!tinfo->isDefined)
|
||||
tinfo->dobj.dump = false;
|
||||
else if (!tyinfo->isDefined)
|
||||
tyinfo->dobj.dump = false;
|
||||
|
||||
else
|
||||
tinfo->dobj.dump = true;
|
||||
tyinfo->dobj.dump = true;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -2340,7 +2340,7 @@ getTypes(int *numTypes)
|
|||
int ntups;
|
||||
int i;
|
||||
PQExpBuffer query = createPQExpBuffer();
|
||||
TypeInfo *tinfo;
|
||||
TypeInfo *tyinfo;
|
||||
ShellTypeInfo *stinfo;
|
||||
int i_tableoid;
|
||||
int i_oid;
|
||||
|
|
@ -2440,7 +2440,7 @@ getTypes(int *numTypes)
|
|||
|
||||
ntups = PQntuples(res);
|
||||
|
||||
tinfo = (TypeInfo *) malloc(ntups * sizeof(TypeInfo));
|
||||
tyinfo = (TypeInfo *) malloc(ntups * sizeof(TypeInfo));
|
||||
|
||||
i_tableoid = PQfnumber(res, "tableoid");
|
||||
i_oid = PQfnumber(res, "oid");
|
||||
|
|
@ -2458,40 +2458,40 @@ getTypes(int *numTypes)
|
|||
|
||||
for (i = 0; i < ntups; i++)
|
||||
{
|
||||
tinfo[i].dobj.objType = DO_TYPE;
|
||||
tinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
|
||||
tinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
|
||||
AssignDumpId(&tinfo[i].dobj);
|
||||
tinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_typname));
|
||||
tinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_typnamespace)),
|
||||
tinfo[i].dobj.catId.oid);
|
||||
tinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
|
||||
tinfo[i].typelem = atooid(PQgetvalue(res, i, i_typelem));
|
||||
tinfo[i].typrelid = atooid(PQgetvalue(res, i, i_typrelid));
|
||||
tinfo[i].typrelkind = *PQgetvalue(res, i, i_typrelkind);
|
||||
tinfo[i].typtype = *PQgetvalue(res, i, i_typtype);
|
||||
tinfo[i].shellType = NULL;
|
||||
tyinfo[i].dobj.objType = DO_TYPE;
|
||||
tyinfo[i].dobj.catId.tableoid = atooid(PQgetvalue(res, i, i_tableoid));
|
||||
tyinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
|
||||
AssignDumpId(&tyinfo[i].dobj);
|
||||
tyinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_typname));
|
||||
tyinfo[i].dobj.namespace = findNamespace(atooid(PQgetvalue(res, i, i_typnamespace)),
|
||||
tyinfo[i].dobj.catId.oid);
|
||||
tyinfo[i].rolname = strdup(PQgetvalue(res, i, i_rolname));
|
||||
tyinfo[i].typelem = atooid(PQgetvalue(res, i, i_typelem));
|
||||
tyinfo[i].typrelid = atooid(PQgetvalue(res, i, i_typrelid));
|
||||
tyinfo[i].typrelkind = *PQgetvalue(res, i, i_typrelkind);
|
||||
tyinfo[i].typtype = *PQgetvalue(res, i, i_typtype);
|
||||
tyinfo[i].shellType = NULL;
|
||||
|
||||
if (strcmp(PQgetvalue(res, i, i_typisdefined), "t") == 0)
|
||||
tinfo[i].isDefined = true;
|
||||
tyinfo[i].isDefined = true;
|
||||
else
|
||||
tinfo[i].isDefined = false;
|
||||
tyinfo[i].isDefined = false;
|
||||
|
||||
if (strcmp(PQgetvalue(res, i, i_isarray), "t") == 0)
|
||||
tinfo[i].isArray = true;
|
||||
tyinfo[i].isArray = true;
|
||||
else
|
||||
tinfo[i].isArray = false;
|
||||
tyinfo[i].isArray = false;
|
||||
|
||||
/* Decide whether we want to dump it */
|
||||
selectDumpableType(&tinfo[i]);
|
||||
selectDumpableType(&tyinfo[i]);
|
||||
|
||||
/*
|
||||
* If it's a domain, fetch info about its constraints, if any
|
||||
*/
|
||||
tinfo[i].nDomChecks = 0;
|
||||
tinfo[i].domChecks = NULL;
|
||||
if (tinfo[i].dobj.dump && tinfo[i].typtype == TYPTYPE_DOMAIN)
|
||||
getDomainConstraints(&(tinfo[i]));
|
||||
tyinfo[i].nDomChecks = 0;
|
||||
tyinfo[i].domChecks = NULL;
|
||||
if (tyinfo[i].dobj.dump && tyinfo[i].typtype == TYPTYPE_DOMAIN)
|
||||
getDomainConstraints(&(tyinfo[i]));
|
||||
|
||||
/*
|
||||
* If it's a base type, make a DumpableObject representing a shell
|
||||
|
|
@ -2502,16 +2502,16 @@ getTypes(int *numTypes)
|
|||
* should copy the base type's catId, but then it might capture the
|
||||
* pg_depend entries for the type, which we don't want.
|
||||
*/
|
||||
if (tinfo[i].dobj.dump && tinfo[i].typtype == TYPTYPE_BASE)
|
||||
if (tyinfo[i].dobj.dump && tyinfo[i].typtype == TYPTYPE_BASE)
|
||||
{
|
||||
stinfo = (ShellTypeInfo *) malloc(sizeof(ShellTypeInfo));
|
||||
stinfo->dobj.objType = DO_SHELL_TYPE;
|
||||
stinfo->dobj.catId = nilCatalogId;
|
||||
AssignDumpId(&stinfo->dobj);
|
||||
stinfo->dobj.name = strdup(tinfo[i].dobj.name);
|
||||
stinfo->dobj.namespace = tinfo[i].dobj.namespace;
|
||||
stinfo->baseType = &(tinfo[i]);
|
||||
tinfo[i].shellType = stinfo;
|
||||
stinfo->dobj.name = strdup(tyinfo[i].dobj.name);
|
||||
stinfo->dobj.namespace = tyinfo[i].dobj.namespace;
|
||||
stinfo->baseType = &(tyinfo[i]);
|
||||
tyinfo[i].shellType = stinfo;
|
||||
|
||||
/*
|
||||
* Initially mark the shell type as not to be dumped. We'll only
|
||||
|
|
@ -2539,7 +2539,7 @@ getTypes(int *numTypes)
|
|||
if (funcInfo && funcInfo->dobj.dump)
|
||||
{
|
||||
/* base type depends on function */
|
||||
addObjectDependency(&tinfo[i].dobj,
|
||||
addObjectDependency(&tyinfo[i].dobj,
|
||||
funcInfo->dobj.dumpId);
|
||||
/* function depends on shell type */
|
||||
addObjectDependency(&funcInfo->dobj,
|
||||
|
|
@ -2552,7 +2552,7 @@ getTypes(int *numTypes)
|
|||
if (funcInfo && funcInfo->dobj.dump)
|
||||
{
|
||||
/* base type depends on function */
|
||||
addObjectDependency(&tinfo[i].dobj,
|
||||
addObjectDependency(&tyinfo[i].dobj,
|
||||
funcInfo->dobj.dumpId);
|
||||
/* function depends on shell type */
|
||||
addObjectDependency(&funcInfo->dobj,
|
||||
|
|
@ -2563,9 +2563,9 @@ getTypes(int *numTypes)
|
|||
}
|
||||
}
|
||||
|
||||
if (strlen(tinfo[i].rolname) == 0 && tinfo[i].isDefined)
|
||||
if (strlen(tyinfo[i].rolname) == 0 && tyinfo[i].isDefined)
|
||||
write_msg(NULL, "WARNING: owner of data type \"%s\" appears to be invalid\n",
|
||||
tinfo[i].dobj.name);
|
||||
tyinfo[i].dobj.name);
|
||||
}
|
||||
|
||||
*numTypes = ntups;
|
||||
|
|
@ -2574,7 +2574,7 @@ getTypes(int *numTypes)
|
|||
|
||||
destroyPQExpBuffer(query);
|
||||
|
||||
return tinfo;
|
||||
return tyinfo;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -4119,7 +4119,7 @@ getConstraints(TableInfo tblinfo[], int numTables)
|
|||
* Get info about constraints on a domain.
|
||||
*/
|
||||
static void
|
||||
getDomainConstraints(TypeInfo *tinfo)
|
||||
getDomainConstraints(TypeInfo *tyinfo)
|
||||
{
|
||||
int i;
|
||||
ConstraintInfo *constrinfo;
|
||||
|
|
@ -4139,7 +4139,7 @@ getDomainConstraints(TypeInfo *tinfo)
|
|||
* select appropriate schema to ensure names in constraint are properly
|
||||
* qualified
|
||||
*/
|
||||
selectSourceSchema(tinfo->dobj.namespace->dobj.name);
|
||||
selectSourceSchema(tyinfo->dobj.namespace->dobj.name);
|
||||
|
||||
query = createPQExpBuffer();
|
||||
|
||||
|
|
@ -4149,14 +4149,14 @@ getDomainConstraints(TypeInfo *tinfo)
|
|||
"FROM pg_catalog.pg_constraint "
|
||||
"WHERE contypid = '%u'::pg_catalog.oid "
|
||||
"ORDER BY conname",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
else
|
||||
appendPQExpBuffer(query, "SELECT tableoid, oid, conname, "
|
||||
"'CHECK (' || consrc || ')' AS consrc "
|
||||
"FROM pg_catalog.pg_constraint "
|
||||
"WHERE contypid = '%u'::pg_catalog.oid "
|
||||
"ORDER BY conname",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
|
||||
res = PQexec(g_conn, query->data);
|
||||
check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
|
||||
|
|
@ -4170,8 +4170,8 @@ getDomainConstraints(TypeInfo *tinfo)
|
|||
|
||||
constrinfo = (ConstraintInfo *) malloc(ntups * sizeof(ConstraintInfo));
|
||||
|
||||
tinfo->nDomChecks = ntups;
|
||||
tinfo->domChecks = constrinfo;
|
||||
tyinfo->nDomChecks = ntups;
|
||||
tyinfo->domChecks = constrinfo;
|
||||
|
||||
for (i = 0; i < ntups; i++)
|
||||
{
|
||||
|
|
@ -4180,9 +4180,9 @@ getDomainConstraints(TypeInfo *tinfo)
|
|||
constrinfo[i].dobj.catId.oid = atooid(PQgetvalue(res, i, i_oid));
|
||||
AssignDumpId(&constrinfo[i].dobj);
|
||||
constrinfo[i].dobj.name = strdup(PQgetvalue(res, i, i_conname));
|
||||
constrinfo[i].dobj.namespace = tinfo->dobj.namespace;
|
||||
constrinfo[i].dobj.namespace = tyinfo->dobj.namespace;
|
||||
constrinfo[i].contable = NULL;
|
||||
constrinfo[i].condomain = tinfo;
|
||||
constrinfo[i].condomain = tyinfo;
|
||||
constrinfo[i].contype = 'c';
|
||||
constrinfo[i].condef = strdup(PQgetvalue(res, i, i_consrc));
|
||||
constrinfo[i].confrelid = InvalidOid;
|
||||
|
|
@ -4196,7 +4196,7 @@ getDomainConstraints(TypeInfo *tinfo)
|
|||
* Make the domain depend on the constraint, ensuring it won't be
|
||||
* output till any constraint dependencies are OK.
|
||||
*/
|
||||
addObjectDependency(&tinfo->dobj,
|
||||
addObjectDependency(&tyinfo->dobj,
|
||||
constrinfo[i].dobj.dumpId);
|
||||
}
|
||||
|
||||
|
|
@ -6368,21 +6368,21 @@ dumpNamespace(Archive *fout, NamespaceInfo *nspinfo)
|
|||
* writes out to fout the queries to recreate a user-defined type
|
||||
*/
|
||||
static void
|
||||
dumpType(Archive *fout, TypeInfo *tinfo)
|
||||
dumpType(Archive *fout, TypeInfo *tyinfo)
|
||||
{
|
||||
/* Skip if not to be dumped */
|
||||
if (!tinfo->dobj.dump || dataOnly)
|
||||
if (!tyinfo->dobj.dump || dataOnly)
|
||||
return;
|
||||
|
||||
/* Dump out in proper style */
|
||||
if (tinfo->typtype == TYPTYPE_BASE)
|
||||
dumpBaseType(fout, tinfo);
|
||||
else if (tinfo->typtype == TYPTYPE_DOMAIN)
|
||||
dumpDomain(fout, tinfo);
|
||||
else if (tinfo->typtype == TYPTYPE_COMPOSITE)
|
||||
dumpCompositeType(fout, tinfo);
|
||||
else if (tinfo->typtype == TYPTYPE_ENUM)
|
||||
dumpEnumType(fout, tinfo);
|
||||
if (tyinfo->typtype == TYPTYPE_BASE)
|
||||
dumpBaseType(fout, tyinfo);
|
||||
else if (tyinfo->typtype == TYPTYPE_DOMAIN)
|
||||
dumpDomain(fout, tyinfo);
|
||||
else if (tyinfo->typtype == TYPTYPE_COMPOSITE)
|
||||
dumpCompositeType(fout, tyinfo);
|
||||
else if (tyinfo->typtype == TYPTYPE_ENUM)
|
||||
dumpEnumType(fout, tyinfo);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -6390,7 +6390,7 @@ dumpType(Archive *fout, TypeInfo *tinfo)
|
|||
* writes out to fout the queries to recreate a user-defined enum type
|
||||
*/
|
||||
static void
|
||||
dumpEnumType(Archive *fout, TypeInfo *tinfo)
|
||||
dumpEnumType(Archive *fout, TypeInfo *tyinfo)
|
||||
{
|
||||
PQExpBuffer q = createPQExpBuffer();
|
||||
PQExpBuffer delq = createPQExpBuffer();
|
||||
|
|
@ -6401,12 +6401,12 @@ dumpEnumType(Archive *fout, TypeInfo *tinfo)
|
|||
char *label;
|
||||
|
||||
/* Set proper schema search path so regproc references list correctly */
|
||||
selectSourceSchema(tinfo->dobj.namespace->dobj.name);
|
||||
selectSourceSchema(tyinfo->dobj.namespace->dobj.name);
|
||||
|
||||
appendPQExpBuffer(query, "SELECT enumlabel FROM pg_catalog.pg_enum "
|
||||
"WHERE enumtypid = '%u'"
|
||||
"ORDER BY oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
|
||||
res = PQexec(g_conn, query->data);
|
||||
check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
|
||||
|
|
@ -6415,7 +6415,7 @@ dumpEnumType(Archive *fout, TypeInfo *tinfo)
|
|||
/* should be at least 1 value */
|
||||
if (num == 0)
|
||||
{
|
||||
write_msg(NULL, "no label definitions found for enum ID %u\n", tinfo->dobj.catId.oid);
|
||||
write_msg(NULL, "no label definitions found for enum ID %u\n", tyinfo->dobj.catId.oid);
|
||||
exit_nicely();
|
||||
}
|
||||
|
||||
|
|
@ -6425,11 +6425,11 @@ dumpEnumType(Archive *fout, TypeInfo *tinfo)
|
|||
* functions are generic and do not get dropped.
|
||||
*/
|
||||
appendPQExpBuffer(delq, "DROP TYPE %s.",
|
||||
fmtId(tinfo->dobj.namespace->dobj.name));
|
||||
fmtId(tyinfo->dobj.namespace->dobj.name));
|
||||
appendPQExpBuffer(delq, "%s;\n",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
appendPQExpBuffer(q, "CREATE TYPE %s AS ENUM (\n",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
for (i = 0; i < num; i++)
|
||||
{
|
||||
label = PQgetvalue(res, i, 0);
|
||||
|
|
@ -6440,23 +6440,23 @@ dumpEnumType(Archive *fout, TypeInfo *tinfo)
|
|||
}
|
||||
appendPQExpBuffer(q, "\n);\n");
|
||||
|
||||
ArchiveEntry(fout, tinfo->dobj.catId, tinfo->dobj.dumpId,
|
||||
tinfo->dobj.name,
|
||||
tinfo->dobj.namespace->dobj.name,
|
||||
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
|
||||
tyinfo->dobj.name,
|
||||
tyinfo->dobj.namespace->dobj.name,
|
||||
NULL,
|
||||
tinfo->rolname, false,
|
||||
tyinfo->rolname, false,
|
||||
"TYPE", SECTION_PRE_DATA,
|
||||
q->data, delq->data, NULL,
|
||||
tinfo->dobj.dependencies, tinfo->dobj.nDeps,
|
||||
tyinfo->dobj.dependencies, tyinfo->dobj.nDeps,
|
||||
NULL, NULL);
|
||||
|
||||
/* Dump Type Comments */
|
||||
resetPQExpBuffer(q);
|
||||
|
||||
appendPQExpBuffer(q, "TYPE %s", fmtId(tinfo->dobj.name));
|
||||
appendPQExpBuffer(q, "TYPE %s", fmtId(tyinfo->dobj.name));
|
||||
dumpComment(fout, q->data,
|
||||
tinfo->dobj.namespace->dobj.name, tinfo->rolname,
|
||||
tinfo->dobj.catId, 0, tinfo->dobj.dumpId);
|
||||
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
|
||||
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
|
||||
|
||||
PQclear(res);
|
||||
destroyPQExpBuffer(q);
|
||||
|
|
@ -6469,7 +6469,7 @@ dumpEnumType(Archive *fout, TypeInfo *tinfo)
|
|||
* writes out to fout the queries to recreate a user-defined base type
|
||||
*/
|
||||
static void
|
||||
dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
||||
dumpBaseType(Archive *fout, TypeInfo *tyinfo)
|
||||
{
|
||||
PQExpBuffer q = createPQExpBuffer();
|
||||
PQExpBuffer delq = createPQExpBuffer();
|
||||
|
|
@ -6501,7 +6501,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
bool typdefault_is_literal = false;
|
||||
|
||||
/* Set proper schema search path so regproc references list correctly */
|
||||
selectSourceSchema(tinfo->dobj.namespace->dobj.name);
|
||||
selectSourceSchema(tyinfo->dobj.namespace->dobj.name);
|
||||
|
||||
/* Fetch type-specific details */
|
||||
if (fout->remoteVersion >= 80400)
|
||||
|
|
@ -6521,7 +6521,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"pg_catalog.pg_get_expr(typdefaultbin, 0) AS typdefaultbin, typdefault "
|
||||
"FROM pg_catalog.pg_type "
|
||||
"WHERE oid = '%u'::pg_catalog.oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else if (fout->remoteVersion >= 80300)
|
||||
{
|
||||
|
|
@ -6541,7 +6541,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
|
||||
"FROM pg_catalog.pg_type "
|
||||
"WHERE oid = '%u'::pg_catalog.oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else if (fout->remoteVersion >= 80000)
|
||||
{
|
||||
|
|
@ -6560,7 +6560,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
|
||||
"FROM pg_catalog.pg_type "
|
||||
"WHERE oid = '%u'::pg_catalog.oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else if (fout->remoteVersion >= 70400)
|
||||
{
|
||||
|
|
@ -6579,7 +6579,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
|
||||
"FROM pg_catalog.pg_type "
|
||||
"WHERE oid = '%u'::pg_catalog.oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else if (fout->remoteVersion >= 70300)
|
||||
{
|
||||
|
|
@ -6598,7 +6598,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
|
||||
"FROM pg_catalog.pg_type "
|
||||
"WHERE oid = '%u'::pg_catalog.oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else if (fout->remoteVersion >= 70200)
|
||||
{
|
||||
|
|
@ -6621,7 +6621,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"NULL AS typdefaultbin, typdefault "
|
||||
"FROM pg_type "
|
||||
"WHERE oid = '%u'::oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else if (fout->remoteVersion >= 70100)
|
||||
{
|
||||
|
|
@ -6644,7 +6644,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"NULL AS typdefaultbin, NULL AS typdefault "
|
||||
"FROM pg_type "
|
||||
"WHERE oid = '%u'::oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -6664,7 +6664,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
"NULL AS typdefaultbin, NULL AS typdefault "
|
||||
"FROM pg_type "
|
||||
"WHERE oid = '%u'::oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
}
|
||||
|
||||
res = PQexec(g_conn, query->data);
|
||||
|
|
@ -6719,14 +6719,14 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
* other way.
|
||||
*/
|
||||
appendPQExpBuffer(delq, "DROP TYPE %s.",
|
||||
fmtId(tinfo->dobj.namespace->dobj.name));
|
||||
fmtId(tyinfo->dobj.namespace->dobj.name));
|
||||
appendPQExpBuffer(delq, "%s CASCADE;\n",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
|
||||
appendPQExpBuffer(q,
|
||||
"CREATE TYPE %s (\n"
|
||||
" INTERNALLENGTH = %s",
|
||||
fmtId(tinfo->dobj.name),
|
||||
fmtId(tyinfo->dobj.name),
|
||||
(strcmp(typlen, "-1") == 0) ? "variable" : typlen);
|
||||
|
||||
if (fout->remoteVersion >= 70300)
|
||||
|
|
@ -6763,13 +6763,13 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
appendPQExpBufferStr(q, typdefault);
|
||||
}
|
||||
|
||||
if (OidIsValid(tinfo->typelem))
|
||||
if (OidIsValid(tyinfo->typelem))
|
||||
{
|
||||
char *elemType;
|
||||
|
||||
/* reselect schema in case changed by function dump */
|
||||
selectSourceSchema(tinfo->dobj.namespace->dobj.name);
|
||||
elemType = getFormattedTypeName(tinfo->typelem, zeroAsOpaque);
|
||||
selectSourceSchema(tyinfo->dobj.namespace->dobj.name);
|
||||
elemType = getFormattedTypeName(tyinfo->typelem, zeroAsOpaque);
|
||||
appendPQExpBuffer(q, ",\n ELEMENT = %s", elemType);
|
||||
free(elemType);
|
||||
}
|
||||
|
|
@ -6812,23 +6812,23 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
|
||||
appendPQExpBuffer(q, "\n);\n");
|
||||
|
||||
ArchiveEntry(fout, tinfo->dobj.catId, tinfo->dobj.dumpId,
|
||||
tinfo->dobj.name,
|
||||
tinfo->dobj.namespace->dobj.name,
|
||||
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
|
||||
tyinfo->dobj.name,
|
||||
tyinfo->dobj.namespace->dobj.name,
|
||||
NULL,
|
||||
tinfo->rolname, false,
|
||||
tyinfo->rolname, false,
|
||||
"TYPE", SECTION_PRE_DATA,
|
||||
q->data, delq->data, NULL,
|
||||
tinfo->dobj.dependencies, tinfo->dobj.nDeps,
|
||||
tyinfo->dobj.dependencies, tyinfo->dobj.nDeps,
|
||||
NULL, NULL);
|
||||
|
||||
/* Dump Type Comments */
|
||||
resetPQExpBuffer(q);
|
||||
|
||||
appendPQExpBuffer(q, "TYPE %s", fmtId(tinfo->dobj.name));
|
||||
appendPQExpBuffer(q, "TYPE %s", fmtId(tyinfo->dobj.name));
|
||||
dumpComment(fout, q->data,
|
||||
tinfo->dobj.namespace->dobj.name, tinfo->rolname,
|
||||
tinfo->dobj.catId, 0, tinfo->dobj.dumpId);
|
||||
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
|
||||
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
|
||||
|
||||
PQclear(res);
|
||||
destroyPQExpBuffer(q);
|
||||
|
|
@ -6841,7 +6841,7 @@ dumpBaseType(Archive *fout, TypeInfo *tinfo)
|
|||
* writes out to fout the queries to recreate a user-defined domain
|
||||
*/
|
||||
static void
|
||||
dumpDomain(Archive *fout, TypeInfo *tinfo)
|
||||
dumpDomain(Archive *fout, TypeInfo *tyinfo)
|
||||
{
|
||||
PQExpBuffer q = createPQExpBuffer();
|
||||
PQExpBuffer delq = createPQExpBuffer();
|
||||
|
|
@ -6855,7 +6855,7 @@ dumpDomain(Archive *fout, TypeInfo *tinfo)
|
|||
bool typdefault_is_literal = false;
|
||||
|
||||
/* Set proper schema search path so type references list correctly */
|
||||
selectSourceSchema(tinfo->dobj.namespace->dobj.name);
|
||||
selectSourceSchema(tyinfo->dobj.namespace->dobj.name);
|
||||
|
||||
/* Fetch domain specific details */
|
||||
/* We assume here that remoteVersion must be at least 70300 */
|
||||
|
|
@ -6864,7 +6864,7 @@ dumpDomain(Archive *fout, TypeInfo *tinfo)
|
|||
"pg_catalog.pg_get_expr(typdefaultbin, 'pg_catalog.pg_type'::pg_catalog.regclass) AS typdefaultbin, typdefault "
|
||||
"FROM pg_catalog.pg_type "
|
||||
"WHERE oid = '%u'::pg_catalog.oid",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
|
||||
res = PQexec(g_conn, query->data);
|
||||
check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
|
||||
|
|
@ -6894,7 +6894,7 @@ dumpDomain(Archive *fout, TypeInfo *tinfo)
|
|||
|
||||
appendPQExpBuffer(q,
|
||||
"CREATE DOMAIN %s AS %s",
|
||||
fmtId(tinfo->dobj.name),
|
||||
fmtId(tyinfo->dobj.name),
|
||||
typdefn);
|
||||
|
||||
if (typnotnull[0] == 't')
|
||||
|
|
@ -6914,9 +6914,9 @@ dumpDomain(Archive *fout, TypeInfo *tinfo)
|
|||
/*
|
||||
* Add any CHECK constraints for the domain
|
||||
*/
|
||||
for (i = 0; i < tinfo->nDomChecks; i++)
|
||||
for (i = 0; i < tyinfo->nDomChecks; i++)
|
||||
{
|
||||
ConstraintInfo *domcheck = &(tinfo->domChecks[i]);
|
||||
ConstraintInfo *domcheck = &(tyinfo->domChecks[i]);
|
||||
|
||||
if (!domcheck->separate)
|
||||
appendPQExpBuffer(q, "\n\tCONSTRAINT %s %s",
|
||||
|
|
@ -6929,27 +6929,27 @@ dumpDomain(Archive *fout, TypeInfo *tinfo)
|
|||
* DROP must be fully qualified in case same name appears in pg_catalog
|
||||
*/
|
||||
appendPQExpBuffer(delq, "DROP DOMAIN %s.",
|
||||
fmtId(tinfo->dobj.namespace->dobj.name));
|
||||
fmtId(tyinfo->dobj.namespace->dobj.name));
|
||||
appendPQExpBuffer(delq, "%s;\n",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
|
||||
ArchiveEntry(fout, tinfo->dobj.catId, tinfo->dobj.dumpId,
|
||||
tinfo->dobj.name,
|
||||
tinfo->dobj.namespace->dobj.name,
|
||||
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
|
||||
tyinfo->dobj.name,
|
||||
tyinfo->dobj.namespace->dobj.name,
|
||||
NULL,
|
||||
tinfo->rolname, false,
|
||||
tyinfo->rolname, false,
|
||||
"DOMAIN", SECTION_PRE_DATA,
|
||||
q->data, delq->data, NULL,
|
||||
tinfo->dobj.dependencies, tinfo->dobj.nDeps,
|
||||
tyinfo->dobj.dependencies, tyinfo->dobj.nDeps,
|
||||
NULL, NULL);
|
||||
|
||||
/* Dump Domain Comments */
|
||||
resetPQExpBuffer(q);
|
||||
|
||||
appendPQExpBuffer(q, "DOMAIN %s", fmtId(tinfo->dobj.name));
|
||||
appendPQExpBuffer(q, "DOMAIN %s", fmtId(tyinfo->dobj.name));
|
||||
dumpComment(fout, q->data,
|
||||
tinfo->dobj.namespace->dobj.name, tinfo->rolname,
|
||||
tinfo->dobj.catId, 0, tinfo->dobj.dumpId);
|
||||
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
|
||||
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
|
||||
|
||||
destroyPQExpBuffer(q);
|
||||
destroyPQExpBuffer(delq);
|
||||
|
|
@ -6962,7 +6962,7 @@ dumpDomain(Archive *fout, TypeInfo *tinfo)
|
|||
* composite type
|
||||
*/
|
||||
static void
|
||||
dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
||||
dumpCompositeType(Archive *fout, TypeInfo *tyinfo)
|
||||
{
|
||||
PQExpBuffer q = createPQExpBuffer();
|
||||
PQExpBuffer delq = createPQExpBuffer();
|
||||
|
|
@ -6974,7 +6974,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
|||
int i;
|
||||
|
||||
/* Set proper schema search path so type references list correctly */
|
||||
selectSourceSchema(tinfo->dobj.namespace->dobj.name);
|
||||
selectSourceSchema(tyinfo->dobj.namespace->dobj.name);
|
||||
|
||||
/* Fetch type specific details */
|
||||
/* We assume here that remoteVersion must be at least 70300 */
|
||||
|
|
@ -6986,7 +6986,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
|||
"AND a.attrelid = t.typrelid "
|
||||
"AND NOT a.attisdropped "
|
||||
"ORDER BY a.attnum ",
|
||||
tinfo->dobj.catId.oid);
|
||||
tyinfo->dobj.catId.oid);
|
||||
|
||||
res = PQexec(g_conn, query->data);
|
||||
check_sql_result(res, g_conn, query->data, PGRES_TUPLES_OK);
|
||||
|
|
@ -7003,7 +7003,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
|||
i_atttypdefn = PQfnumber(res, "atttypdefn");
|
||||
|
||||
appendPQExpBuffer(q, "CREATE TYPE %s AS (",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
|
||||
for (i = 0; i < ntups; i++)
|
||||
{
|
||||
|
|
@ -7023,28 +7023,28 @@ dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
|||
* DROP must be fully qualified in case same name appears in pg_catalog
|
||||
*/
|
||||
appendPQExpBuffer(delq, "DROP TYPE %s.",
|
||||
fmtId(tinfo->dobj.namespace->dobj.name));
|
||||
fmtId(tyinfo->dobj.namespace->dobj.name));
|
||||
appendPQExpBuffer(delq, "%s;\n",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
|
||||
ArchiveEntry(fout, tinfo->dobj.catId, tinfo->dobj.dumpId,
|
||||
tinfo->dobj.name,
|
||||
tinfo->dobj.namespace->dobj.name,
|
||||
ArchiveEntry(fout, tyinfo->dobj.catId, tyinfo->dobj.dumpId,
|
||||
tyinfo->dobj.name,
|
||||
tyinfo->dobj.namespace->dobj.name,
|
||||
NULL,
|
||||
tinfo->rolname, false,
|
||||
tyinfo->rolname, false,
|
||||
"TYPE", SECTION_PRE_DATA,
|
||||
q->data, delq->data, NULL,
|
||||
tinfo->dobj.dependencies, tinfo->dobj.nDeps,
|
||||
tyinfo->dobj.dependencies, tyinfo->dobj.nDeps,
|
||||
NULL, NULL);
|
||||
|
||||
|
||||
/* Dump Type Comments */
|
||||
resetPQExpBuffer(q);
|
||||
|
||||
appendPQExpBuffer(q, "TYPE %s", fmtId(tinfo->dobj.name));
|
||||
appendPQExpBuffer(q, "TYPE %s", fmtId(tyinfo->dobj.name));
|
||||
dumpComment(fout, q->data,
|
||||
tinfo->dobj.namespace->dobj.name, tinfo->rolname,
|
||||
tinfo->dobj.catId, 0, tinfo->dobj.dumpId);
|
||||
tyinfo->dobj.namespace->dobj.name, tyinfo->rolname,
|
||||
tyinfo->dobj.catId, 0, tyinfo->dobj.dumpId);
|
||||
|
||||
PQclear(res);
|
||||
destroyPQExpBuffer(q);
|
||||
|
|
@ -7052,7 +7052,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
|||
destroyPQExpBuffer(query);
|
||||
|
||||
/* Dump any per-column comments */
|
||||
dumpCompositeTypeColComments(fout, tinfo);
|
||||
dumpCompositeTypeColComments(fout, tyinfo);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -7061,7 +7061,7 @@ dumpCompositeType(Archive *fout, TypeInfo *tinfo)
|
|||
* a user-defined stand-alone composite type
|
||||
*/
|
||||
static void
|
||||
dumpCompositeTypeColComments(Archive *fout, TypeInfo *tinfo)
|
||||
dumpCompositeTypeColComments(Archive *fout, TypeInfo *tyinfo)
|
||||
{
|
||||
CommentItem *comments;
|
||||
int ncomments;
|
||||
|
|
@ -7083,7 +7083,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tinfo)
|
|||
"WHERE c.oid = '%u' AND c.oid = a.attrelid "
|
||||
" AND NOT a.attisdropped "
|
||||
"ORDER BY a.attnum ",
|
||||
tinfo->typrelid);
|
||||
tyinfo->typrelid);
|
||||
|
||||
/* Fetch column attnames */
|
||||
res = PQexec(g_conn, query->data);
|
||||
|
|
@ -7102,7 +7102,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tinfo)
|
|||
/* Search for comments associated with type's pg_class OID */
|
||||
ncomments = findComments(fout,
|
||||
pgClassOid,
|
||||
tinfo->typrelid,
|
||||
tyinfo->typrelid,
|
||||
&comments);
|
||||
|
||||
/* If no comments exist, we're done */
|
||||
|
|
@ -7137,7 +7137,7 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tinfo)
|
|||
|
||||
resetPQExpBuffer(target);
|
||||
appendPQExpBuffer(target, "COLUMN %s.",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
appendPQExpBuffer(target, "%s",
|
||||
fmtId(attname));
|
||||
|
||||
|
|
@ -7148,11 +7148,11 @@ dumpCompositeTypeColComments(Archive *fout, TypeInfo *tinfo)
|
|||
|
||||
ArchiveEntry(fout, nilCatalogId, createDumpId(),
|
||||
target->data,
|
||||
tinfo->dobj.namespace->dobj.name,
|
||||
NULL, tinfo->rolname,
|
||||
tyinfo->dobj.namespace->dobj.name,
|
||||
NULL, tyinfo->rolname,
|
||||
false, "COMMENT", SECTION_NONE,
|
||||
query->data, "", NULL,
|
||||
&(tinfo->dobj.dumpId), 1,
|
||||
&(tyinfo->dobj.dumpId), 1,
|
||||
NULL, NULL);
|
||||
}
|
||||
|
||||
|
|
@ -10972,13 +10972,13 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
|
|||
else if (coninfo->contype == 'c' && tbinfo == NULL)
|
||||
{
|
||||
/* CHECK constraint on a domain */
|
||||
TypeInfo *tinfo = coninfo->condomain;
|
||||
TypeInfo *tyinfo = coninfo->condomain;
|
||||
|
||||
/* Ignore if not to be dumped separately */
|
||||
if (coninfo->separate)
|
||||
{
|
||||
appendPQExpBuffer(q, "ALTER DOMAIN %s\n",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
appendPQExpBuffer(q, " ADD CONSTRAINT %s %s;\n",
|
||||
fmtId(coninfo->dobj.name),
|
||||
coninfo->condef);
|
||||
|
|
@ -10988,17 +10988,17 @@ dumpConstraint(Archive *fout, ConstraintInfo *coninfo)
|
|||
* pg_catalog
|
||||
*/
|
||||
appendPQExpBuffer(delq, "ALTER DOMAIN %s.",
|
||||
fmtId(tinfo->dobj.namespace->dobj.name));
|
||||
fmtId(tyinfo->dobj.namespace->dobj.name));
|
||||
appendPQExpBuffer(delq, "%s ",
|
||||
fmtId(tinfo->dobj.name));
|
||||
fmtId(tyinfo->dobj.name));
|
||||
appendPQExpBuffer(delq, "DROP CONSTRAINT %s;\n",
|
||||
fmtId(coninfo->dobj.name));
|
||||
|
||||
ArchiveEntry(fout, coninfo->dobj.catId, coninfo->dobj.dumpId,
|
||||
coninfo->dobj.name,
|
||||
tinfo->dobj.namespace->dobj.name,
|
||||
tyinfo->dobj.namespace->dobj.name,
|
||||
NULL,
|
||||
tinfo->rolname, false,
|
||||
tyinfo->rolname, false,
|
||||
"CHECK CONSTRAINT", SECTION_POST_DATA,
|
||||
q->data, delq->data, NULL,
|
||||
coninfo->dobj.dependencies, coninfo->dobj.nDeps,
|
||||
|
|
|
|||
Loading…
Reference in New Issue