From 07b39083c2aca003c4b1f289d7dc2368b5e2297a Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Wed, 31 Jul 2019 15:42:49 -0400 Subject: [PATCH] Fix pg_dump's handling of dependencies for custom opclasses. Since pg_dump doesn't treat the member operators and functions of operator classes/families (that is, the pg_amop and pg_amproc entries, not the underlying operators/functions) as separate dumpable objects, it missed their dependency information. I think this was safe when the code was designed, because the default object sorting rule emits operators and functions before opclasses, and there were no dependency types that could mess that up. However, the introduction of range types in 9.2 broke it: now a type can have a dependency on an opclass, allowing dependency rules to push the opclass before the type and hence before custom operators. Lacking any information showing that it shouldn't do so, pg_dump emitted the objects in the wrong order. Fix by teaching getDependencies() to translate pg_depend entries for pg_amop/amproc rows to look like dependencies for their parent opfamily. I added a regression test for this in HEAD/v12, but not further back; life is too short to fight with 002_pg_dump.pl. Per bug #15934 from Tom Gottfried. Back-patch to all supported branches. Discussion: https://postgr.es/m/15934-58b8c8ab7a09ea15@postgresql.org --- src/bin/pg_dump/pg_dump.c | 35 ++++++++++++++++++++++++++++++-- src/bin/pg_dump/t/002_pg_dump.pl | 29 ++++++++++++++++++++++++++ 2 files changed, 62 insertions(+), 2 deletions(-) diff --git a/src/bin/pg_dump/pg_dump.c b/src/bin/pg_dump/pg_dump.c index 8a31672247..0cc9eded24 100644 --- a/src/bin/pg_dump/pg_dump.c +++ b/src/bin/pg_dump/pg_dump.c @@ -17911,14 +17911,45 @@ getDependencies(Archive *fout) query = createPQExpBuffer(); /* + * Messy query to collect the dependency data we need. Note that we + * ignore the sub-object column, so that dependencies of or on a column + * look the same as dependencies of or on a whole table. + * * PIN dependencies aren't interesting, and EXTENSION dependencies were * already processed by getExtensionMembership. */ appendPQExpBufferStr(query, "SELECT " "classid, objid, refclassid, refobjid, deptype " "FROM pg_depend " - "WHERE deptype != 'p' AND deptype != 'e' " - "ORDER BY 1,2"); + "WHERE deptype != 'p' AND deptype != 'e'\n"); + + /* + * Since we don't treat pg_amop entries as separate DumpableObjects, we + * have to translate their dependencies into dependencies of their parent + * opfamily. Ignore internal dependencies though, as those will point to + * their parent opclass, which we needn't consider here (and if we did, + * it'd just result in circular dependencies). Also, "loose" opfamily + * entries will have dependencies on their parent opfamily, which we + * should drop since they'd likewise become useless self-dependencies. + * (But be sure to keep deps on *other* opfamilies; see amopsortfamily.) + */ + appendPQExpBufferStr(query, "UNION ALL\n" + "SELECT 'pg_opfamily'::regclass AS classid, amopfamily AS objid, refclassid, refobjid, deptype " + "FROM pg_depend d, pg_amop o " + "WHERE deptype NOT IN ('p', 'e', 'i') AND " + "classid = 'pg_amop'::regclass AND objid = o.oid " + "AND NOT (refclassid = 'pg_opfamily'::regclass AND amopfamily = refobjid)\n"); + + /* Likewise for pg_amproc entries */ + appendPQExpBufferStr(query, "UNION ALL\n" + "SELECT 'pg_opfamily'::regclass AS classid, amprocfamily AS objid, refclassid, refobjid, deptype " + "FROM pg_depend d, pg_amproc p " + "WHERE deptype NOT IN ('p', 'e', 'i') AND " + "classid = 'pg_amproc'::regclass AND objid = p.oid " + "AND NOT (refclassid = 'pg_opfamily'::regclass AND amprocfamily = refobjid)\n"); + + /* Sort the output for efficiency below */ + appendPQExpBufferStr(query, "ORDER BY 1,2"); res = ExecuteSqlQuery(fout, query->data, PGRES_TUPLES_OK); diff --git a/src/bin/pg_dump/t/002_pg_dump.pl b/src/bin/pg_dump/t/002_pg_dump.pl index 7cbccee103..f064ea1063 100644 --- a/src/bin/pg_dump/t/002_pg_dump.pl +++ b/src/bin/pg_dump/t/002_pg_dump.pl @@ -1571,6 +1571,35 @@ my %tests = ( unlike => { exclude_dump_test_schema => 1, }, }, + # verify that a custom operator/opclass/range type is dumped in right order + 'CREATE OPERATOR CLASS dump_test.op_class_custom' => { + create_order => 74, + create_sql => 'CREATE OPERATOR dump_test.~~ ( + PROCEDURE = int4eq, + LEFTARG = int, + RIGHTARG = int); + CREATE OPERATOR CLASS dump_test.op_class_custom + FOR TYPE int USING btree AS + OPERATOR 3 dump_test.~~; + CREATE TYPE dump_test.range_type_custom AS RANGE ( + subtype = int, + subtype_opclass = dump_test.op_class_custom);', + regexp => qr/^ + \QCREATE OPERATOR dump_test.~~ (\E\n.+ + \QCREATE OPERATOR FAMILY dump_test.op_class_custom USING btree;\E\n.+ + \QCREATE OPERATOR CLASS dump_test.op_class_custom\E\n\s+ + \QFOR TYPE integer USING btree FAMILY dump_test.op_class_custom AS\E\n\s+ + \QOPERATOR 3 dump_test.~~(integer,integer);\E\n.+ + \QCREATE TYPE dump_test.range_type_custom AS RANGE (\E\n\s+ + \Qsubtype = integer,\E\n\s+ + \Qsubtype_opclass = dump_test.op_class_custom\E\n + \Q);\E + /xms, + like => + { %full_runs, %dump_test_schema_runs, section_pre_data => 1, }, + unlike => { exclude_dump_test_schema => 1, }, + }, + 'CREATE OPERATOR CLASS dump_test.op_class_empty' => { create_order => 89, create_sql => 'CREATE OPERATOR CLASS dump_test.op_class_empty