public inbox for [email protected]
help / color / mirror / Atom feedFrom: Denis Garsh <[email protected]>
To: [email protected] <[email protected]>
Subject: Add system column support to the USING clause
Date: Fri, 13 Sep 2024 11:03:42 +0300
Message-ID: <[email protected]> (raw)
------==--bound.60954.kxm5fi5dn62wfkjr.vla.yp-c.yandex.net
Content-Transfer-Encoding: base64
Content-Type: text/html; charset=utf-8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=
------==--bound.60954.kxm5fi5dn62wfkjr.vla.yp-c.yandex.net
Content-Disposition: attachment;
filename="v1-0001-Add-system-column-support-to-the-USING-clause.patch"
Content-Transfer-Encoding: base64
Content-Type: text/x-diff;
name="v1-0001-Add-system-column-support-to-the-USING-clause.patch"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------==--bound.60954.kxm5fi5dn62wfkjr.vla.yp-c.yandex.net--
Attachments:
[text/x-diff] v1-0001-Add-system-column-support-to-the-USING-clause.patch (16.7K, ../[email protected]/2-v1-0001-Add-system-column-support-to-the-USING-clause.patch)
download | inline diff:
From 295f9ec59b22cc3707fb8f168e0e3750e51724a0 Mon Sep 17 00:00:00 2001
From: Denis Garsh <[email protected]>
Date: Wed, 7 Aug 2024 15:57:32 +0300
Subject: [PATCH] Add system column support to the USING clause
Problem: The parser can't handle USING joins with system columns, such as xmin.
Solution:
1. Use the scanNSItemForColumn() function instead of buildVarFromNSColumn() for
constructing Var objects, as it correctly handles system columns.
2. Remove extra calls to markVarForSelectPriv(), since this function is already
invoked in scanNSItemForColumn().
3. For system columns, collect their negative attribute numbers along with
user-defined column indices into l_colnos and r_colnos.
4. Create a buildVarFromSystemAttribute() function for rebuilding Var objects
with system attributes, analogous to buildVarFromNSColumn(), since
scanNSItemForColumn() is complex and has side effects.
5. Implement a fillNSColumnParametersFromVar() function for building NS columns
with system attributes.
6. Add SystemAttributeTotalNumber() function to heap.c to ensure memory for
res_nscolumns is allocated with system columns in mind.
---
src/backend/catalog/heap.c | 8 ++
src/backend/parser/parse_clause.c | 178 ++++++++++++++++++++++++++---
src/include/catalog/heap.h | 2 +
src/test/regress/expected/join.out | 106 +++++++++++++++++
src/test/regress/sql/join.sql | 54 +++++++++
5 files changed, 330 insertions(+), 18 deletions(-)
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 01b43cc6a8..b44d0d0005 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -264,6 +264,14 @@ SystemAttributeByName(const char *attname)
return NULL;
}
+/*
+ * Returns the total number of system attributes.
+ */
+size_t SystemAttributeTotalNumber(void)
+{
+ return lengthof(SysAtt);
+}
+
/* ----------------------------------------------------------------
* XXX END OF UGLY HARD CODED BADNESS XXX
diff --git a/src/backend/parser/parse_clause.c b/src/backend/parser/parse_clause.c
index 8118036495..8e99d78272 100644
--- a/src/backend/parser/parse_clause.c
+++ b/src/backend/parser/parse_clause.c
@@ -24,6 +24,7 @@
#include "catalog/pg_amproc.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_type.h"
+#include "catalog/heap.h"
#include "commands/defrem.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
@@ -76,6 +77,10 @@ static Node *transformFromClauseItem(ParseState *pstate, Node *n,
List **namespace);
static Var *buildVarFromNSColumn(ParseState *pstate,
ParseNamespaceColumn *nscol);
+static Var *buildVarFromSystemAttribute(ParseState *pstate,
+ int rtindex, int attnum);
+static void fillNSColumnParametersFromVar(ParseNamespaceColumn *rescolumn,
+ const Var *colvar);
static Node *buildMergedJoinVar(ParseState *pstate, JoinType jointype,
Var *l_colvar, Var *r_colvar);
static void markRelsAsNulledBy(ParseState *pstate, Node *n, int jindex);
@@ -273,7 +278,16 @@ extractRemainingColumns(ParseState *pstate,
prevcols = NULL;
foreach(lc, *src_colnos)
{
- prevcols = bms_add_member(prevcols, lfirst_int(lc));
+ int col_index = lfirst_int(lc);
+ if (col_index < 0)
+ {
+ /*
+ * Attribute number of system column. Don't collect the number
+ * because the name of this column cannot be among src_colnames.
+ */
+ continue;
+ }
+ prevcols = bms_add_member(prevcols, col_index);
}
attnum = 0;
@@ -327,10 +341,6 @@ transformJoinUsingClause(ParseState *pstate,
Var *rvar = (Var *) lfirst(rvars);
A_Expr *e;
- /* Require read access to the join variables */
- markVarForSelectPriv(pstate, lvar);
- markVarForSelectPriv(pstate, rvar);
-
/* Now create the lvar = rvar join condition */
e = makeSimpleA_Expr(AEXPR_OP, "=",
(Node *) copyObject(lvar), (Node *) copyObject(rvar),
@@ -1291,7 +1301,9 @@ transformFromClauseItem(ParseState *pstate, Node *n,
/* this may be larger than needed, but it's not worth being exact */
res_nscolumns = (ParseNamespaceColumn *)
- palloc0((list_length(l_colnames) + list_length(r_colnames)) *
+ palloc0((list_length(l_colnames) +
+ list_length(r_colnames) +
+ SystemAttributeTotalNumber()) *
sizeof(ParseNamespaceColumn));
res_colindex = 0;
@@ -1332,6 +1344,14 @@ transformFromClauseItem(ParseState *pstate, Node *n,
u_colname)));
}
+ /*
+ * It is important to understand that among the l_colnames or
+ * r_colnames there may be a system column name. A system
+ * column name may appear if it was added in the previous step.
+ * This is because a query can contain multiple USING joins,
+ * where each join uses the result of the previous one.
+ */
+
/* Find it in left input */
ndx = 0;
foreach(col, l_colnames)
@@ -1349,12 +1369,25 @@ transformFromClauseItem(ParseState *pstate, Node *n,
}
ndx++;
}
- if (l_index < 0)
+
+ l_colvar = (Var *) scanNSItemForColumn(pstate,
+ l_nsitem,
+ 0, u_colname, -1);
+ if (l_colvar == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("column \"%s\" specified in USING clause does not exist in left table",
u_colname)));
- l_colnos = lappend_int(l_colnos, l_index + 1);
+ if (l_index >= 0)
+ {
+ /* User-defined column */
+ l_colnos = lappend_int(l_colnos, l_index + 1);
+ }
+ else
+ {
+ /* System column */
+ l_colnos = lappend_int(l_colnos, l_colvar->varattno);
+ }
/* Find it in right input */
ndx = 0;
@@ -1373,17 +1406,30 @@ transformFromClauseItem(ParseState *pstate, Node *n,
}
ndx++;
}
- if (r_index < 0)
+
+ r_colvar = (Var *) scanNSItemForColumn(pstate,
+ r_nsitem,
+ 0, u_colname, -1);
+
+ if (r_colvar == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("column \"%s\" specified in USING clause does not exist in right table",
u_colname)));
- r_colnos = lappend_int(r_colnos, r_index + 1);
+
+ if (r_index >= 0)
+ {
+ /* User-defined column */
+ r_colnos = lappend_int(r_colnos, r_index + 1);
+ }
+ else
+ {
+ /* System column */
+ r_colnos = lappend_int(r_colnos, r_colvar->varattno);
+ }
/* Build Vars to use in the generated JOIN ON clause */
- l_colvar = buildVarFromNSColumn(pstate, l_nscolumns + l_index);
l_usingvars = lappend(l_usingvars, l_colvar);
- r_colvar = buildVarFromNSColumn(pstate, r_nscolumns + r_index);
r_usingvars = lappend(r_usingvars, r_colvar);
/*
@@ -1461,8 +1507,8 @@ transformFromClauseItem(ParseState *pstate, Node *n,
/* Scan the colnos lists to recover info from the previous loop */
forboth(lc1, l_colnos, lc2, r_colnos)
{
- int l_index = lfirst_int(lc1) - 1;
- int r_index = lfirst_int(lc2) - 1;
+ int l_index = lfirst_int(lc1);
+ int r_index = lfirst_int(lc2);
Var *l_colvar,
*r_colvar;
Node *u_colvar;
@@ -1472,8 +1518,33 @@ transformFromClauseItem(ParseState *pstate, Node *n,
* Note we re-build these Vars: they might have different
* varnullingrels than the ones made in the previous loop.
*/
- l_colvar = buildVarFromNSColumn(pstate, l_nscolumns + l_index);
- r_colvar = buildVarFromNSColumn(pstate, r_nscolumns + r_index);
+ if (l_index > 0)
+ {
+ /* User-defined column */
+ l_colvar = buildVarFromNSColumn(pstate,
+ l_nscolumns + l_index - 1);
+ }
+ else
+ {
+ /* System column, so l_index is attnum. */
+ l_colvar = buildVarFromSystemAttribute(pstate,
+ l_nsitem->p_rtindex,
+ l_index);
+ }
+
+ if (r_index > 0)
+ {
+ /* User-defined column */
+ r_colvar = buildVarFromNSColumn(pstate,
+ r_nscolumns + r_index - 1);
+ }
+ else
+ {
+ /* System column, so r_index is attnum. */
+ r_colvar = buildVarFromSystemAttribute(pstate,
+ r_nsitem->p_rtindex,
+ r_index);
+ }
/* Construct the join alias Var for this column */
u_colvar = buildMergedJoinVar(pstate,
@@ -1488,12 +1559,32 @@ transformFromClauseItem(ParseState *pstate, Node *n,
if (u_colvar == (Node *) l_colvar)
{
/* Merged column is equivalent to left input */
- *res_nscolumn = l_nscolumns[l_index];
+ if (l_index > 0)
+ {
+ /* User-defined column, so just take it. */
+ *res_nscolumn = l_nscolumns[l_index - 1];
+ }
+ else
+ {
+ /* System column, so construct new column. */
+ fillNSColumnParametersFromVar(res_nscolumn,
+ l_colvar);
+ }
}
else if (u_colvar == (Node *) r_colvar)
{
/* Merged column is equivalent to right input */
- *res_nscolumn = r_nscolumns[r_index];
+ if (r_index > 0)
+ {
+ /* User-defined column, so just take it. */
+ *res_nscolumn = r_nscolumns[r_index - 1];
+ }
+ else
+ {
+ /* System column, so construct new column. */
+ fillNSColumnParametersFromVar(res_nscolumn,
+ r_colvar);
+ }
}
else
{
@@ -1658,6 +1749,57 @@ buildVarFromNSColumn(ParseState *pstate, ParseNamespaceColumn *nscol)
return var;
}
+/*
+ * buildVarFromSystemAttribute -
+ * build a Var node using system attribute, e.g. "xmin".
+ *
+ * rtindex is the relation's index in the rangetable.
+ * attnum is the number of system attribute.
+ * Returns NULL if there is no such system attribute.
+ */
+static Var *
+buildVarFromSystemAttribute(ParseState *pstate, int rtindex, int attnum)
+{
+ Var *var;
+ const FormData_pg_attribute *sysatt;
+
+ sysatt = SystemAttributeDefinition(attnum);
+
+ if (sysatt == NULL)
+ return NULL;
+
+ var = makeVar(rtindex,
+ attnum,
+ sysatt->atttypid,
+ sysatt->atttypmod,
+ sysatt->attcollation,
+ 0);
+
+ /* update varnullingrels */
+ markNullableIfNeeded(pstate, var);
+ return var;
+}
+
+/*
+ * fillNSColumnParametersFromVar -
+ * fill ParseNamespaceColumn data using Var data.
+ *
+ * rescolumn is pointer to the structure to be filled.
+ * colvar is the Var where to get data from.
+ */
+static void
+fillNSColumnParametersFromVar(ParseNamespaceColumn *rescolumn,
+ const Var *colvar)
+{
+ rescolumn->p_varno = colvar->varno;
+ rescolumn->p_varattno = colvar->varattno;
+ rescolumn->p_vartype = colvar->vartype;
+ rescolumn->p_vartypmod = colvar->vartypmod;
+ rescolumn->p_varcollid = colvar->varcollid;
+ rescolumn->p_varnosyn = colvar->varnosyn;
+ rescolumn->p_varattnosyn = colvar->varattnosyn;
+}
+
/*
* buildMergedJoinVar -
* generate a suitable replacement expression for a merged join column
diff --git a/src/include/catalog/heap.h b/src/include/catalog/heap.h
index c512824cd1..960db152b5 100644
--- a/src/include/catalog/heap.h
+++ b/src/include/catalog/heap.h
@@ -136,6 +136,8 @@ extern const FormData_pg_attribute *SystemAttributeDefinition(AttrNumber attno);
extern const FormData_pg_attribute *SystemAttributeByName(const char *attname);
+extern size_t SystemAttributeTotalNumber(void);
+
extern void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind,
int flags);
diff --git a/src/test/regress/expected/join.out b/src/test/regress/expected/join.out
index 31fb7d142e..1ea9a1ab71 100644
--- a/src/test/regress/expected/join.out
+++ b/src/test/regress/expected/join.out
@@ -8017,3 +8017,109 @@ SELECT t1.a FROM skip_fetch t1 LEFT JOIN skip_fetch t2 ON t2.a = 1 WHERE t2.a IS
RESET enable_indexonlyscan;
RESET enable_seqscan;
+-- Test USING with system columns
+-- Generate 2 tables with 3 rows each.
+-- xmin (transaction number) is an integer value represented as T1, T2, etc.
+-- The xmin values of the first and second rows are equal to each other,
+-- respectively. The values T3 and T4 of the third rows are not equal.
+-- J1: id1 | xmin J2: id2 | xmin
+-- ----+------- -----+-------
+-- 1 | T1 101 | T1
+-- 2 | T2 102 | T2
+-- 3 | T3 103 | T4
+CREATE TABLE j1 (id1 INT);
+CREATE TABLE j2 (id2 INT);
+BEGIN;
+ INSERT INTO j1 (id1) VALUES (1);
+ INSERT INTO j2 (id2) VALUES (101);
+COMMIT;
+BEGIN;
+ INSERT INTO j1 (id1) VALUES (2);
+ INSERT INTO j2 (id2) VALUES (102);
+COMMIT;
+BEGIN;
+ INSERT INTO j1 (id1) VALUES (3);
+COMMIT;
+BEGIN;
+ INSERT INTO j2 (id2) VALUES (103);
+COMMIT;
+-- The xmin values are not output, as they will differ with each run.
+-- So, only the column headers and the values of id1 and id2 are displayed.
+SELECT * FROM j1 JOIN j2 USING (xmin) LIMIT 0;
+ xmin | id1 | id2
+------+-----+-----
+(0 rows)
+
+SELECT j1.id1, j2.id2 FROM j1 JOIN j2 USING (xmin);
+ id1 | id2
+-----+-----
+ 1 | 101
+ 2 | 102
+(2 rows)
+
+SELECT * FROM j1 LEFT JOIN j2 USING (xmin) LIMIT 0;
+ xmin | id1 | id2
+------+-----+-----
+(0 rows)
+
+SELECT j1.id1, j2.id2 FROM j1 LEFT JOIN j2 USING (xmin);
+ id1 | id2
+-----+-----
+ 1 | 101
+ 2 | 102
+ 3 |
+(3 rows)
+
+SELECT * FROM j1 RIGHT JOIN j2 USING (xmin) LIMIT 0;
+ xmin | id1 | id2
+------+-----+-----
+(0 rows)
+
+SELECT j1.id1, j2.id2 FROM j1 RIGHT JOIN j2 USING (xmin);
+ id1 | id2
+-----+-----
+ 1 | 101
+ 2 | 102
+ | 103
+(3 rows)
+
+SELECT * FROM j1 FULL JOIN j2 USING (xmin) LIMIT 0;
+ xmin | id1 | id2
+------+-----+-----
+(0 rows)
+
+SELECT j1.id1, j2.id2 FROM j1 FULL JOIN j2 USING (xmin);
+ id1 | id2
+-----+-----
+ 1 | 101
+ 2 | 102
+ 3 |
+ | 103
+(4 rows)
+
+-- Test if USING can add all system columns at once
+SELECT *
+ FROM j1 JOIN j2 USING (tableoid, xmin, cmin, xmax, cmax, ctid);
+ tableoid | xmin | cmin | xmax | cmax | ctid | id1 | id2
+----------+------+------+------+------+------+-----+-----
+(0 rows)
+
+-- Test USING exceptions
+SELECT * FROM j1 JOIN j2 USING (id2);
+ERROR: column "id2" specified in USING clause does not exist in left table
+SELECT * FROM j1 JOIN j2 USING (id1);
+ERROR: column "id1" specified in USING clause does not exist in right table
+WITH j1_dubbed AS (SELECT id1, id1 FROM j1)
+ SELECT * FROM j1_dubbed JOIN j1 USING (id1);
+ERROR: common column name "id1" appears more than once in left table
+WITH j1_dubbed AS (SELECT id1, id1 FROM j1)
+ SELECT * FROM j1 JOIN j1_dubbed USING (id1);
+ERROR: common column name "id1" appears more than once in right table
+-- Test multiple USING joins, each based on the prior result.
+CREATE TABLE j3 (id3 INT);
+SELECT * FROM j1 JOIN j2 USING (xmin) JOIN j3 USING (xmin) LIMIT 0;
+ xmin | id1 | id2 | id3
+------+-----+-----+-----
+(0 rows)
+
+DROP TABLE j1, J2, J3;
diff --git a/src/test/regress/sql/join.sql b/src/test/regress/sql/join.sql
index d81ff63be5..f49c730e56 100644
--- a/src/test/regress/sql/join.sql
+++ b/src/test/regress/sql/join.sql
@@ -2952,3 +2952,57 @@ SELECT t1.a FROM skip_fetch t1 LEFT JOIN skip_fetch t2 ON t2.a = 1 WHERE t2.a IS
RESET enable_indexonlyscan;
RESET enable_seqscan;
+
+-- Test USING with system columns
+
+-- Generate 2 tables with 3 rows each.
+-- xmin (transaction number) is an integer value represented as T1, T2, etc.
+-- The xmin values of the first and second rows are equal to each other,
+-- respectively. The values T3 and T4 of the third rows are not equal.
+-- J1: id1 | xmin J2: id2 | xmin
+-- ----+------- -----+-------
+-- 1 | T1 101 | T1
+-- 2 | T2 102 | T2
+-- 3 | T3 103 | T4
+CREATE TABLE j1 (id1 INT);
+CREATE TABLE j2 (id2 INT);
+BEGIN;
+ INSERT INTO j1 (id1) VALUES (1);
+ INSERT INTO j2 (id2) VALUES (101);
+COMMIT;
+BEGIN;
+ INSERT INTO j1 (id1) VALUES (2);
+ INSERT INTO j2 (id2) VALUES (102);
+COMMIT;
+BEGIN;
+ INSERT INTO j1 (id1) VALUES (3);
+COMMIT;
+BEGIN;
+ INSERT INTO j2 (id2) VALUES (103);
+COMMIT;
+
+-- The xmin values are not output, as they will differ with each run.
+-- So, only the column headers and the values of id1 and id2 are displayed.
+SELECT * FROM j1 JOIN j2 USING (xmin) LIMIT 0;
+SELECT j1.id1, j2.id2 FROM j1 JOIN j2 USING (xmin);
+SELECT * FROM j1 LEFT JOIN j2 USING (xmin) LIMIT 0;
+SELECT j1.id1, j2.id2 FROM j1 LEFT JOIN j2 USING (xmin);
+SELECT * FROM j1 RIGHT JOIN j2 USING (xmin) LIMIT 0;
+SELECT j1.id1, j2.id2 FROM j1 RIGHT JOIN j2 USING (xmin);
+SELECT * FROM j1 FULL JOIN j2 USING (xmin) LIMIT 0;
+SELECT j1.id1, j2.id2 FROM j1 FULL JOIN j2 USING (xmin);
+-- Test if USING can add all system columns at once
+SELECT *
+ FROM j1 JOIN j2 USING (tableoid, xmin, cmin, xmax, cmax, ctid);
+-- Test USING exceptions
+SELECT * FROM j1 JOIN j2 USING (id2);
+SELECT * FROM j1 JOIN j2 USING (id1);
+WITH j1_dubbed AS (SELECT id1, id1 FROM j1)
+ SELECT * FROM j1_dubbed JOIN j1 USING (id1);
+WITH j1_dubbed AS (SELECT id1, id1 FROM j1)
+ SELECT * FROM j1 JOIN j1_dubbed USING (id1);
+-- Test multiple USING joins, each based on the prior result.
+CREATE TABLE j3 (id3 INT);
+SELECT * FROM j1 JOIN j2 USING (xmin) JOIN j3 USING (xmin) LIMIT 0;
+
+DROP TABLE j1, J2, J3;
--
2.34.1
view thread (3+ messages) latest in thread
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected]
Subject: Re: Add system column support to the USING clause
In-Reply-To: <[email protected]>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox