open-dsi
/
postgres
mirror of https://github.com/postgres/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Rename pg_dump.c TypeInfo variable tinfo to tyinfo, for clarity.

Browse Source
REL9_0_ALPHA4_BRANCH
Bruce Momjian 16 years ago
parent cfc5008a51
commit b683908064
1 changed files with 157 additions and 157 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 314
      src/bin/pg_dump/pg_dump.c

314
src/bin/pg_dump/pg_dump.c
Unescape View File

@ -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,

Write Preview
Loading…
Cancel
Save