Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commita4424c5

Browse files
committed
Remove unnecessary restrictions about RowExprs in transformAExprIn().
When the existing code here was written, it made sense to special-caseRowExprs because that was the only way that we could handle row comparisonsat all. Now that we have record_eq() and arrays of composites, the genericlogic for "scalar" types will in fact work on RowExprs too, so there's noreason to throw error for combinations of RowExprs and other ways offorming composite values, nor to ignore the possibility of using aScalarArrayOpExpr. But keep using the old logic when comparing twoRowExprs, for consistency with the main transformAExprOp() logic. (Thisallows some cases with not-quite-identical rowtypes to succeed, so we mightget push-back if we removed it.) Per bug #8198 from Rafal Rzepecki.Back-patch to all supported branches, since this works fine as far back as8.4.Rafal Rzepecki and Tom Lane
1 parentf3839ea commita4424c5

File tree

3 files changed

+93
-24
lines changed

3 files changed

+93
-24
lines changed

‎src/backend/parser/parse_expr.c

Lines changed: 24 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -889,7 +889,7 @@ transformAExprOp(ParseState *pstate, A_Expr *a)
889889
elseif (lexpr&&IsA(lexpr,RowExpr)&&
890890
rexpr&&IsA(rexpr,RowExpr))
891891
{
892-
/*"row oprow" */
892+
/*ROW() opROW() is handled specially */
893893
lexpr=transformExprRecurse(pstate,lexpr);
894894
rexpr=transformExprRecurse(pstate,rexpr);
895895
Assert(IsA(lexpr,RowExpr));
@@ -994,7 +994,7 @@ transformAExprDistinct(ParseState *pstate, A_Expr *a)
994994
if (lexpr&&IsA(lexpr,RowExpr)&&
995995
rexpr&&IsA(rexpr,RowExpr))
996996
{
997-
/*"row oprow" */
997+
/*ROW() opROW() is handled specially */
998998
returnmake_row_distinct_op(pstate,a->name,
999999
(RowExpr*)lexpr,
10001000
(RowExpr*)rexpr,
@@ -1093,7 +1093,6 @@ transformAExprIn(ParseState *pstate, A_Expr *a)
10931093
List*rvars;
10941094
List*rnonvars;
10951095
booluseOr;
1096-
boolhaveRowExpr;
10971096
ListCell*l;
10981097

10991098
/*
@@ -1106,24 +1105,21 @@ transformAExprIn(ParseState *pstate, A_Expr *a)
11061105

11071106
/*
11081107
* We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
1109-
* possible if the inputs are all scalars (no RowExprs) and there is a
1110-
* suitable array type available. If not, we fall back to a boolean
1111-
* condition tree with multiple copies of the lefthand expression. Also,
1112-
* any IN-list items that contain Vars are handled as separate boolean
1113-
* conditions, because that gives the planner more scope for optimization
1114-
* on such clauses.
1108+
* possible if there is a suitable array type available. If not, we fall
1109+
* back to a boolean condition tree with multiple copies of the lefthand
1110+
* expression.Also, any IN-list items that contain Vars are handled as
1111+
* separate boolean conditions, because that gives the planner more scope
1112+
* for optimization on such clauses.
11151113
*
1116-
* First step: transform all the inputs, and detect whether anyare
1117-
*RowExprs or containVars.
1114+
* First step: transform all the inputs, and detect whether anycontain
1115+
* Vars.
11181116
*/
11191117
lexpr=transformExprRecurse(pstate,a->lexpr);
1120-
haveRowExpr= (lexpr&&IsA(lexpr,RowExpr));
11211118
rexprs=rvars=rnonvars=NIL;
11221119
foreach(l, (List*)a->rexpr)
11231120
{
11241121
Node*rexpr=transformExprRecurse(pstate,lfirst(l));
11251122

1126-
haveRowExpr |= (rexpr&&IsA(rexpr,RowExpr));
11271123
rexprs=lappend(rexprs,rexpr);
11281124
if (contain_vars_of_level(rexpr,0))
11291125
rvars=lappend(rvars,rexpr);
@@ -1133,9 +1129,9 @@ transformAExprIn(ParseState *pstate, A_Expr *a)
11331129

11341130
/*
11351131
* ScalarArrayOpExpr is only going to be useful if there's more than one
1136-
* non-Var righthand item.Also, it won't work for RowExprs.
1132+
* non-Var righthand item.
11371133
*/
1138-
if (!haveRowExpr&&list_length(rnonvars)>1)
1134+
if (list_length(rnonvars)>1)
11391135
{
11401136
List*allexprs;
11411137
Oidscalar_type;
@@ -1151,8 +1147,13 @@ transformAExprIn(ParseState *pstate, A_Expr *a)
11511147
allexprs=list_concat(list_make1(lexpr),rnonvars);
11521148
scalar_type=select_common_type(pstate,allexprs,NULL,NULL);
11531149

1154-
/* Do we have an array type to use? */
1155-
if (OidIsValid(scalar_type))
1150+
/*
1151+
* Do we have an array type to use? Aside from the case where there
1152+
* isn't one, we don't risk using ScalarArrayOpExpr when the common
1153+
* type is RECORD, because the RowExpr comparison logic below can cope
1154+
* with some cases of non-identical row types.
1155+
*/
1156+
if (OidIsValid(scalar_type)&&scalar_type!=RECORDOID)
11561157
array_type=get_array_type(scalar_type);
11571158
else
11581159
array_type=InvalidOid;
@@ -1203,26 +1204,25 @@ transformAExprIn(ParseState *pstate, A_Expr *a)
12031204
Node*rexpr= (Node*)lfirst(l);
12041205
Node*cmp;
12051206

1206-
if (haveRowExpr)
1207+
if (IsA(lexpr,RowExpr)&&
1208+
IsA(rexpr,RowExpr))
12071209
{
1208-
if (!IsA(lexpr,RowExpr)||
1209-
!IsA(rexpr,RowExpr))
1210-
ereport(ERROR,
1211-
(errcode(ERRCODE_SYNTAX_ERROR),
1212-
errmsg("arguments of row IN must all be row expressions"),
1213-
parser_errposition(pstate,a->location)));
1210+
/* ROW() op ROW() is handled specially */
12141211
cmp=make_row_comparison_op(pstate,
12151212
a->name,
12161213
(List*)copyObject(((RowExpr*)lexpr)->args),
12171214
((RowExpr*)rexpr)->args,
12181215
a->location);
12191216
}
12201217
else
1218+
{
1219+
/* Ordinary scalar operator */
12211220
cmp= (Node*)make_op(pstate,
12221221
a->name,
12231222
copyObject(lexpr),
12241223
rexpr,
12251224
a->location);
1225+
}
12261226

12271227
cmp=coerce_to_boolean(pstate,cmp,"IN");
12281228
if (result==NULL)

‎src/test/regress/expected/rowtypes.out

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -205,6 +205,25 @@ ERROR: could not determine interpretation of row comparison operator ~~
205205
LINE 1: select ROW('ABC','DEF') ~~ ROW('DEF','ABC') as fail;
206206
^
207207
HINT: Row comparison operators must be associated with btree operator families.
208+
-- Comparisons of ROW() expressions can cope with some type mismatches
209+
select ROW(1,2) = ROW(1,2::int8);
210+
?column?
211+
----------
212+
t
213+
(1 row)
214+
215+
select ROW(1,2) in (ROW(3,4), ROW(1,2));
216+
?column?
217+
----------
218+
t
219+
(1 row)
220+
221+
select ROW(1,2) in (ROW(3,4), ROW(1,2::int8));
222+
?column?
223+
----------
224+
t
225+
(1 row)
226+
208227
-- Check row comparison with a subselect
209228
select unique1, unique2 from tenk1
210229
where (unique1, unique2) < any (select ten, ten from tenk1 where hundred < 3)
@@ -217,6 +236,16 @@ order by 1;
217236
(2 rows)
218237

219238
-- Also check row comparison with an indexable condition
239+
explain (costs off)
240+
select thousand, tenthous from tenk1
241+
where (thousand, tenthous) >= (997, 5000)
242+
order by thousand, tenthous;
243+
QUERY PLAN
244+
-----------------------------------------------------------
245+
Index Only Scan using tenk1_thous_tenthous on tenk1
246+
Index Cond: (ROW(thousand, tenthous) >= ROW(997, 5000))
247+
(2 rows)
248+
220249
select thousand, tenthous from tenk1
221250
where (thousand, tenthous) >= (997, 5000)
222251
order by thousand, tenthous;
@@ -249,6 +278,26 @@ order by thousand, tenthous;
249278
999 | 9999
250279
(25 rows)
251280

281+
-- Check row comparisons with IN
282+
select * from int8_tbl i8 where i8 in (row(123,456)); -- fail, type mismatch
283+
ERROR: cannot compare dissimilar column types bigint and integer at record column 1
284+
explain (costs off)
285+
select * from int8_tbl i8
286+
where i8 in (row(123,456)::int8_tbl, '(4567890123456789,123)');
287+
QUERY PLAN
288+
-------------------------------------------------------------------------------------------------------------
289+
Seq Scan on int8_tbl i8
290+
Filter: (i8.* = ANY (ARRAY[ROW(123::bigint, 456::bigint)::int8_tbl, '(4567890123456789,123)'::int8_tbl]))
291+
(2 rows)
292+
293+
select * from int8_tbl i8
294+
where i8 in (row(123,456)::int8_tbl, '(4567890123456789,123)');
295+
q1 | q2
296+
------------------+-----
297+
123 | 456
298+
4567890123456789 | 123
299+
(2 rows)
300+
252301
-- Check some corner cases involving empty rowtypes
253302
select ROW();
254303
row

‎src/test/regress/sql/rowtypes.sql

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -95,17 +95,37 @@ select ROW('ABC','DEF') ~<=~ ROW('DEF','ABC') as true;
9595
select ROW('ABC','DEF') ~>=~ ROW('DEF','ABC')as false;
9696
select ROW('ABC','DEF') ~~ ROW('DEF','ABC')as fail;
9797

98+
-- Comparisons of ROW() expressions can cope with some type mismatches
99+
select ROW(1,2)= ROW(1,2::int8);
100+
select ROW(1,2)in (ROW(3,4), ROW(1,2));
101+
select ROW(1,2)in (ROW(3,4), ROW(1,2::int8));
102+
98103
-- Check row comparison with a subselect
99104
select unique1, unique2from tenk1
100105
where (unique1, unique2)< any (select ten, tenfrom tenk1where hundred<3)
101106
and unique1<=20
102107
order by1;
103108

104109
-- Also check row comparison with an indexable condition
110+
explain (costs off)
111+
select thousand, tenthousfrom tenk1
112+
where (thousand, tenthous)>= (997,5000)
113+
order by thousand, tenthous;
114+
105115
select thousand, tenthousfrom tenk1
106116
where (thousand, tenthous)>= (997,5000)
107117
order by thousand, tenthous;
108118

119+
-- Check row comparisons with IN
120+
select*from int8_tbl i8where i8in (row(123,456));-- fail, type mismatch
121+
122+
explain (costs off)
123+
select*from int8_tbl i8
124+
where i8in (row(123,456)::int8_tbl,'(4567890123456789,123)');
125+
126+
select*from int8_tbl i8
127+
where i8in (row(123,456)::int8_tbl,'(4567890123456789,123)');
128+
109129
-- Check some corner cases involving empty rowtypes
110130
select ROW();
111131
select ROW() ISNULL;

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp