From dffc82a5b9d48bded63e1beed718b24bbf58c6a4 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Tue, 1 Dec 2020 14:02:27 -0500 Subject: [PATCH] Ensure that expandTableLikeClause() re-examines the same table. As it stood, expandTableLikeClause() re-did the same relation_openrv call that transformTableLikeClause() had done. However there are scenarios where this would not find the same table as expected. We hold lock on the LIKE source table, so it can't be renamed or dropped, but another table could appear before it in the search path. This explains the odd behavior reported in bug #16758 when cloning a table as a temp table of the same name. This case worked as expected before commit 502898192 introduced the need to open the source table twice, so we should fix it. To make really sure we get the same table, let's re-open it by OID not name. That requires adding an OID field to struct TableLikeClause, which is a little nervous-making from an ABI standpoint, but as long as it's at the end I don't think there's any serious risk. Per bug #16758 from Marc Boeren. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/16758-840e84a6cfab276d@postgresql.org --- src/backend/nodes/copyfuncs.c | 1 + src/backend/nodes/equalfuncs.c | 1 + src/backend/nodes/outfuncs.c | 1 + src/backend/parser/gram.y | 1 + src/backend/parser/parse_utilcmd.c | 14 ++++++++++--- src/include/nodes/parsenodes.h | 1 + .../regress/expected/create_table_like.out | 21 +++++++++++++++++++ src/test/regress/sql/create_table_like.sql | 8 +++++++ 8 files changed, 45 insertions(+), 3 deletions(-) diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c index d8cf87e6d08..256ab540038 100644 --- a/src/backend/nodes/copyfuncs.c +++ b/src/backend/nodes/copyfuncs.c @@ -3419,6 +3419,7 @@ _copyTableLikeClause(const TableLikeClause *from) COPY_NODE_FIELD(relation); COPY_SCALAR_FIELD(options); + COPY_SCALAR_FIELD(relationOid); return newnode; } diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c index 627b026b195..8dc50aea811 100644 --- a/src/backend/nodes/equalfuncs.c +++ b/src/backend/nodes/equalfuncs.c @@ -1260,6 +1260,7 @@ _equalTableLikeClause(const TableLikeClause *a, const TableLikeClause *b) { COMPARE_NODE_FIELD(relation); COMPARE_SCALAR_FIELD(options); + COMPARE_SCALAR_FIELD(relationOid); return true; } diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c index 07c93b4737a..1af3bf47879 100644 --- a/src/backend/nodes/outfuncs.c +++ b/src/backend/nodes/outfuncs.c @@ -2810,6 +2810,7 @@ _outTableLikeClause(StringInfo str, const TableLikeClause *node) WRITE_NODE_FIELD(relation); WRITE_UINT_FIELD(options); + WRITE_OID_FIELD(relationOid); } static void diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y index 6f0205145d4..3adc087e3ff 100644 --- a/src/backend/parser/gram.y +++ b/src/backend/parser/gram.y @@ -3629,6 +3629,7 @@ TableLikeClause: TableLikeClause *n = makeNode(TableLikeClause); n->relation = $2; n->options = $3; + n->relationOid = InvalidOid; $$ = (Node *)n; } ; diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c index 4641db21cab..c4076a3868b 100644 --- a/src/backend/parser/parse_utilcmd.c +++ b/src/backend/parser/parse_utilcmd.c @@ -1102,14 +1102,18 @@ transformTableLikeClause(CreateStmtContext *cxt, TableLikeClause *table_like_cla * we don't yet know what column numbers the copied columns will have in * the finished table. If any of those options are specified, add the * LIKE clause to cxt->likeclauses so that expandTableLikeClause will be - * called after we do know that. + * called after we do know that. Also, remember the relation OID so that + * expandTableLikeClause is certain to open the same table. */ if (table_like_clause->options & (CREATE_TABLE_LIKE_DEFAULTS | CREATE_TABLE_LIKE_GENERATED | CREATE_TABLE_LIKE_CONSTRAINTS | CREATE_TABLE_LIKE_INDEXES)) + { + table_like_clause->relationOid = RelationGetRelid(relation); cxt->likeclauses = lappend(cxt->likeclauses, table_like_clause); + } /* * We may copy extended statistics if requested, since the representation @@ -1182,9 +1186,13 @@ expandTableLikeClause(RangeVar *heapRel, TableLikeClause *table_like_clause) * Open the relation referenced by the LIKE clause. We should still have * the table lock obtained by transformTableLikeClause (and this'll throw * an assertion failure if not). Hence, no need to recheck privileges - * etc. + * etc. We must open the rel by OID not name, to be sure we get the same + * table. */ - relation = relation_openrv(table_like_clause->relation, NoLock); + if (!OidIsValid(table_like_clause->relationOid)) + elog(ERROR, "expandTableLikeClause called on untransformed LIKE clause"); + + relation = relation_open(table_like_clause->relationOid, NoLock); tupleDesc = RelationGetDescr(relation); constr = tupleDesc->constr; diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h index 5af71e35325..557074c2cf1 100644 --- a/src/include/nodes/parsenodes.h +++ b/src/include/nodes/parsenodes.h @@ -672,6 +672,7 @@ typedef struct TableLikeClause NodeTag type; RangeVar *relation; bits32 options; /* OR of TableLikeOption flags */ + Oid relationOid; /* If table has been looked up, its OID */ } TableLikeClause; typedef enum TableLikeOption diff --git a/src/test/regress/expected/create_table_like.out b/src/test/regress/expected/create_table_like.out index 01e3a8435da..10d17be23cf 100644 --- a/src/test/regress/expected/create_table_like.out +++ b/src/test/regress/expected/create_table_like.out @@ -455,6 +455,27 @@ Statistics objects: "public"."pg_attrdef_a_b_stat" (ndistinct, dependencies, mcv) ON a, b FROM public.pg_attrdef DROP TABLE public.pg_attrdef; +-- Check that LIKE isn't confused when new table masks the old, either +BEGIN; +CREATE SCHEMA ctl_schema; +SET LOCAL search_path = ctl_schema, public; +CREATE TABLE ctlt1 (LIKE ctlt1 INCLUDING ALL); +\d+ ctlt1 + Table "ctl_schema.ctlt1" + Column | Type | Collation | Nullable | Default | Storage | Stats target | Description +--------+------+-----------+----------+---------+----------+--------------+------------- + a | text | | not null | | main | | A + b | text | | | | extended | | B +Indexes: + "ctlt1_pkey" PRIMARY KEY, btree (a) + "ctlt1_b_idx" btree (b) + "ctlt1_expr_idx" btree ((a || b)) +Check constraints: + "ctlt1_a_check" CHECK (length(a) > 2) +Statistics objects: + "ctl_schema"."ctlt1_a_b_stat" (ndistinct, dependencies, mcv) ON a, b FROM ctlt1 + +ROLLBACK; DROP TABLE ctlt1, ctlt2, ctlt3, ctlt4, ctlt12_storage, ctlt12_comments, ctlt1_inh, ctlt13_inh, ctlt13_like, ctlt_all, ctla, ctlb CASCADE; NOTICE: drop cascades to table inhe -- LIKE must respect NO INHERIT property of constraints diff --git a/src/test/regress/sql/create_table_like.sql b/src/test/regress/sql/create_table_like.sql index 63548b3d11d..06b76f949d6 100644 --- a/src/test/regress/sql/create_table_like.sql +++ b/src/test/regress/sql/create_table_like.sql @@ -173,6 +173,14 @@ CREATE TABLE pg_attrdef (LIKE ctlt1 INCLUDING ALL); \d+ public.pg_attrdef DROP TABLE public.pg_attrdef; +-- Check that LIKE isn't confused when new table masks the old, either +BEGIN; +CREATE SCHEMA ctl_schema; +SET LOCAL search_path = ctl_schema, public; +CREATE TABLE ctlt1 (LIKE ctlt1 INCLUDING ALL); +\d+ ctlt1 +ROLLBACK; + DROP TABLE ctlt1, ctlt2, ctlt3, ctlt4, ctlt12_storage, ctlt12_comments, ctlt1_inh, ctlt13_inh, ctlt13_like, ctlt_all, ctla, ctlb CASCADE; -- LIKE must respect NO INHERIT property of constraints