?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Make to_timestamp and friends skip leading spaces before an integer field,
[PostgreSQL.git] / src / backend / parser / parse_expr.c
blob46fecd23a325adaf011b7dc68bf3d615c91b80ad
1 /*-------------------------------------------------------------------------
2 *
3 * parse_expr.c
4 * handle expressions in parser
5 *
6 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * $PostgreSQL$
12 *
13 *-------------------------------------------------------------------------
14 */
15
16 #include "postgres.h"
17
18 #include "catalog/pg_type.h"
19 #include "commands/dbcommands.h"
20 #include "miscadmin.h"
21 #include "nodes/makefuncs.h"
22 #include "nodes/nodeFuncs.h"
23 #include "optimizer/var.h"
24 #include "parser/analyze.h"
25 #include "parser/parse_coerce.h"
26 #include "parser/parse_expr.h"
27 #include "parser/parse_func.h"
28 #include "parser/parse_oper.h"
29 #include "parser/parse_relation.h"
30 #include "parser/parse_target.h"
31 #include "parser/parse_type.h"
32 #include "utils/builtins.h"
33 #include "utils/lsyscache.h"
34 #include "utils/xml.h"
35
36
37 bool Transform_null_equals = false;
38
39 static Node *transformParamRef(ParseState *pstate, ParamRef *pref);
40 static Node *transformAExprOp(ParseState *pstate, A_Expr *a);
41 static Node *transformAExprAnd(ParseState *pstate, A_Expr *a);
42 static Node *transformAExprOr(ParseState *pstate, A_Expr *a);
43 static Node *transformAExprNot(ParseState *pstate, A_Expr *a);
44 static Node *transformAExprOpAny(ParseState *pstate, A_Expr *a);
45 static Node *transformAExprOpAll(ParseState *pstate, A_Expr *a);
46 static Node *transformAExprDistinct(ParseState *pstate, A_Expr *a);
47 static Node *transformAExprNullIf(ParseState *pstate, A_Expr *a);
48 static Node *transformAExprOf(ParseState *pstate, A_Expr *a);
49 static Node *transformAExprIn(ParseState *pstate, A_Expr *a);
50 static Node *transformFuncCall(ParseState *pstate, FuncCall *fn);
51 static Node *transformCaseExpr(ParseState *pstate, CaseExpr *c);
52 static Node *transformSubLink(ParseState *pstate, SubLink *sublink);
53 static Node *transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
54 Oid array_type, Oid element_type, int32 typmod);
55 static Node *transformRowExpr(ParseState *pstate, RowExpr *r);
56 static Node *transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c);
57 static Node *transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m);
58 static Node *transformXmlExpr(ParseState *pstate, XmlExpr *x);
59 static Node *transformXmlSerialize(ParseState *pstate, XmlSerialize *xs);
60 static Node *transformBooleanTest(ParseState *pstate, BooleanTest *b);
61 static Node *transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr);
62 static Node *transformColumnRef(ParseState *pstate, ColumnRef *cref);
63 static Node *transformWholeRowRef(ParseState *pstate, char *schemaname,
64 char *relname, int location);
65 static Node *transformIndirection(ParseState *pstate, Node *basenode,
66 List *indirection);
67 static Node *transformTypeCast(ParseState *pstate, TypeCast *tc);
68 static Node *make_row_comparison_op(ParseState *pstate, List *opname,
69 List *largs, List *rargs, int location);
70 static Node *make_row_distinct_op(ParseState *pstate, List *opname,
71 RowExpr *lrow, RowExpr *rrow, int location);
72 static Expr *make_distinct_op(ParseState *pstate, List *opname,
73 Node *ltree, Node *rtree, int location);
74
75
76 /*
77 * transformExpr -
78 * Analyze and transform expressions. Type checking and type casting is
79 * done here. The optimizer and the executor cannot handle the original
80 * (raw) expressions collected by the parse tree. Hence the transformation
81 * here.
82 *
83 * NOTE: there are various cases in which this routine will get applied to
84 * an already-transformed expression. Some examples:
85 * 1. At least one construct (BETWEEN/AND) puts the same nodes
86 * into two branches of the parse tree; hence, some nodes
87 * are transformed twice.
88 * 2. Another way it can happen is that coercion of an operator or
89 * function argument to the required type (via coerce_type())
90 * can apply transformExpr to an already-transformed subexpression.
91 * An example here is "SELECT count(*) + 1.0 FROM table".
92 * While it might be possible to eliminate these cases, the path of
93 * least resistance so far has been to ensure that transformExpr() does
94 * no damage if applied to an already-transformed tree. This is pretty
95 * easy for cases where the transformation replaces one node type with
96 * another, such as A_Const => Const; we just do nothing when handed
97 * a Const. More care is needed for node types that are used as both
98 * input and output of transformExpr; see SubLink for example.
99 */
100 Node *
101 transformExpr(ParseState *pstate, Node *expr)
102 {
103 Node *result = NULL;
104
105 if (expr == NULL)
106 return NULL;
107
108 /* Guard against stack overflow due to overly complex expressions */
109 check_stack_depth();
110
111 switch (nodeTag(expr))
112 {
113 case T_ColumnRef:
114 result = transformColumnRef(pstate, (ColumnRef *) expr);
115 break;
116
117 case T_ParamRef:
118 result = transformParamRef(pstate, (ParamRef *) expr);
119 break;
120
121 case T_A_Const:
122 {
123 A_Const *con = (A_Const *) expr;
124 Value *val = &con->val;
125
126 result = (Node *) make_const(pstate, val, con->location);
127 break;
128 }
129
130 case T_A_Indirection:
131 {
132 A_Indirection *ind = (A_Indirection *) expr;
133
134 result = transformExpr(pstate, ind->arg);
135 result = transformIndirection(pstate, result,
136 ind->indirection);
137 break;
138 }
139
140 case T_A_ArrayExpr:
141 result = transformArrayExpr(pstate, (A_ArrayExpr *) expr,
142 InvalidOid, InvalidOid, -1);
143 break;
144
145 case T_TypeCast:
146 {
147 TypeCast *tc = (TypeCast *) expr;
148
149 /*
150 * If the subject of the typecast is an ARRAY[] construct and
151 * the target type is an array type, we invoke
152 * transformArrayExpr() directly so that we can pass down the
153 * type information. This avoids some cases where
154 * transformArrayExpr() might not infer the correct type.
155 */
156 if (IsA(tc->arg, A_ArrayExpr))
157 {
158 Oid targetType;
159 Oid elementType;
160 int32 targetTypmod;
161
162 targetType = typenameTypeId(pstate, tc->typename,
163 &targetTypmod);
164 elementType = get_element_type(targetType);
165 if (OidIsValid(elementType))
166 {
167 result = transformArrayExpr(pstate,
168 (A_ArrayExpr *) tc->arg,
169 targetType,
170 elementType,
171 targetTypmod);
172 break;
173 }
174
175 /*
176 * Corner case: ARRAY[] cast to a non-array type. Fall
177 * through to do it the standard way.
178 */
179 }
180
181 result = transformTypeCast(pstate, tc);
182 break;
183 }
184
185 case T_A_Expr:
186 {
187 A_Expr *a = (A_Expr *) expr;
188
189 switch (a->kind)
190 {
191 case AEXPR_OP:
192 result = transformAExprOp(pstate, a);
193 break;
194 case AEXPR_AND:
195 result = transformAExprAnd(pstate, a);
196 break;
197 case AEXPR_OR:
198 result = transformAExprOr(pstate, a);
199 break;
200 case AEXPR_NOT:
201 result = transformAExprNot(pstate, a);
202 break;
203 case AEXPR_OP_ANY:
204 result = transformAExprOpAny(pstate, a);
205 break;
206 case AEXPR_OP_ALL:
207 result = transformAExprOpAll(pstate, a);
208 break;
209 case AEXPR_DISTINCT:
210 result = transformAExprDistinct(pstate, a);
211 break;
212 case AEXPR_NULLIF:
213 result = transformAExprNullIf(pstate, a);
214 break;
215 case AEXPR_OF:
216 result = transformAExprOf(pstate, a);
217 break;
218 case AEXPR_IN:
219 result = transformAExprIn(pstate, a);
220 break;
221 default:
222 elog(ERROR, "unrecognized A_Expr kind: %d", a->kind);
223 }
224 break;
225 }
226
227 case T_FuncCall:
228 result = transformFuncCall(pstate, (FuncCall *) expr);
229 break;
230
231 case T_SubLink:
232 result = transformSubLink(pstate, (SubLink *) expr);
233 break;
234
235 case T_CaseExpr:
236 result = transformCaseExpr(pstate, (CaseExpr *) expr);
237 break;
238
239 case T_RowExpr:
240 result = transformRowExpr(pstate, (RowExpr *) expr);
241 break;
242
243 case T_CoalesceExpr:
244 result = transformCoalesceExpr(pstate, (CoalesceExpr *) expr);
245 break;
246
247 case T_MinMaxExpr:
248 result = transformMinMaxExpr(pstate, (MinMaxExpr *) expr);
249 break;
250
251 case T_XmlExpr:
252 result = transformXmlExpr(pstate, (XmlExpr *) expr);
253 break;
254
255 case T_XmlSerialize:
256 result = transformXmlSerialize(pstate, (XmlSerialize *) expr);
257 break;
258
259 case T_NullTest:
260 {
261 NullTest *n = (NullTest *) expr;
262
263 n->arg = (Expr *) transformExpr(pstate, (Node *) n->arg);
264 /* the argument can be any type, so don't coerce it */
265 result = expr;
266 break;
267 }
268
269 case T_BooleanTest:
270 result = transformBooleanTest(pstate, (BooleanTest *) expr);
271 break;
272
273 case T_CurrentOfExpr:
274 result = transformCurrentOfExpr(pstate, (CurrentOfExpr *) expr);
275 break;
276
277 /*********************************************
278 * Quietly accept node types that may be presented when we are
279 * called on an already-transformed tree.
280 *
281 * Do any other node types need to be accepted? For now we are
282 * taking a conservative approach, and only accepting node
283 * types that are demonstrably necessary to accept.
284 *********************************************/
285 case T_Var:
286 case T_Const:
287 case T_Param:
288 case T_Aggref:
289 case T_WindowFunc:
290 case T_ArrayRef:
291 case T_FuncExpr:
292 case T_OpExpr:
293 case T_DistinctExpr:
294 case T_ScalarArrayOpExpr:
295 case T_NullIfExpr:
296 case T_BoolExpr:
297 case T_FieldSelect:
298 case T_FieldStore:
299 case T_RelabelType:
300 case T_CoerceViaIO:
301 case T_ArrayCoerceExpr:
302 case T_ConvertRowtypeExpr:
303 case T_CaseTestExpr:
304 case T_CoerceToDomain:
305 case T_CoerceToDomainValue:
306 case T_SetToDefault:
307 {
308 result = (Node *) expr;
309 break;
310 }
311
312 default:
313 /* should not reach here */
314 elog(ERROR, "unrecognized node type: %d", (int) nodeTag(expr));
315 break;
316 }
317
318 return result;
319 }
320
321 static Node *
322 transformIndirection(ParseState *pstate, Node *basenode, List *indirection)
323 {
324 Node *result = basenode;
325 List *subscripts = NIL;
326 ListCell *i;
327
328 /*
329 * We have to split any field-selection operations apart from
330 * subscripting. Adjacent A_Indices nodes have to be treated as a single
331 * multidimensional subscript operation.
332 */
333 foreach(i, indirection)
334 {
335 Node *n = lfirst(i);
336
337 if (IsA(n, A_Indices))
338 subscripts = lappend(subscripts, n);
339 else if (IsA(n, A_Star))
340 {
341 ereport(ERROR,
342 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
343 errmsg("row expansion via \"*\" is not supported here"),
344 parser_errposition(pstate, exprLocation(basenode))));
345 }
346 else
347 {
348 Assert(IsA(n, String));
349
350 /* process subscripts before this field selection */
351 if (subscripts)
352 result = (Node *) transformArraySubscripts(pstate,
353 result,
354 exprType(result),
355 InvalidOid,
356 exprTypmod(result),
357 subscripts,
358 NULL);
359 subscripts = NIL;
360
361 result = ParseFuncOrColumn(pstate,
362 list_make1(n),
363 list_make1(result),
364 false, false, false,
365 NULL, true, -1);
366 }
367 }
368 /* process trailing subscripts, if any */
369 if (subscripts)
370 result = (Node *) transformArraySubscripts(pstate,
371 result,
372 exprType(result),
373 InvalidOid,
374 exprTypmod(result),
375 subscripts,
376 NULL);
377
378 return result;
379 }
380
381 static Node *
382 transformColumnRef(ParseState *pstate, ColumnRef *cref)
383 {
384 int numnames = list_length(cref->fields);
385 Node *node;
386 int levels_up;
387
388 /*----------
389 * The allowed syntaxes are:
390 *
391 * A First try to resolve as unqualified column name;
392 * if no luck, try to resolve as unqualified table name (A.*).
393 * A.B A is an unqualified table name; B is either a
394 * column or function name (trying column name first).
395 * A.B.C schema A, table B, col or func name C.
396 * A.B.C.D catalog A, schema B, table C, col or func D.
397 * A.* A is an unqualified table name; means whole-row value.
398 * A.B.* whole-row value of table B in schema A.
399 * A.B.C.* whole-row value of table C in schema B in catalog A.
400 *
401 * We do not need to cope with bare "*"; that will only be accepted by
402 * the grammar at the top level of a SELECT list, and transformTargetList
403 * will take care of it before it ever gets here. Also, "A.*" etc will
404 * be expanded by transformTargetList if they appear at SELECT top level,
405 * so here we are only going to see them as function or operator inputs.
406 *
407 * Currently, if a catalog name is given then it must equal the current
408 * database name; we check it here and then discard it.
409 *----------
410 */
411 switch (numnames)
412 {
413 case 1:
414 {
415 Node *field1 = (Node *) linitial(cref->fields);
416 char *name1;
417
418 Assert(IsA(field1, String));
419 name1 = strVal(field1);
420
421 /* Try to identify as an unqualified column */
422 node = colNameToVar(pstate, name1, false, cref->location);
423
424 if (node == NULL)
425 {
426 /*
427 * Not known as a column of any range-table entry.
428 *
429 * Consider the possibility that it's VALUE in a domain
430 * check expression. (We handle VALUE as a name, not a
431 * keyword, to avoid breaking a lot of applications that
432 * have used VALUE as a column name in the past.)
433 */
434 if (pstate->p_value_substitute != NULL &&
435 strcmp(name1, "value") == 0)
436 {
437 node = (Node *) copyObject(pstate->p_value_substitute);
438
439 /*
440 * Try to propagate location knowledge. This should
441 * be extended if p_value_substitute can ever take on
442 * other node types.
443 */
444 if (IsA(node, CoerceToDomainValue))
445 ((CoerceToDomainValue *) node)->location = cref->location;
446 break;
447 }
448
449 /*
450 * Try to find the name as a relation. Note that only
451 * relations already entered into the rangetable will be
452 * recognized.
453 *
454 * This is a hack for backwards compatibility with
455 * PostQUEL-inspired syntax. The preferred form now is
456 * "rel.*".
457 */
458 if (refnameRangeTblEntry(pstate, NULL, name1,
459 cref->location,
460 &levels_up) != NULL)
461 node = transformWholeRowRef(pstate, NULL, name1,
462 cref->location);
463 else
464 ereport(ERROR,
465 (errcode(ERRCODE_UNDEFINED_COLUMN),
466 errmsg("column \"%s\" does not exist",
467 name1),
468 parser_errposition(pstate, cref->location)));
469 }
470 break;
471 }
472 case 2:
473 {
474 Node *field1 = (Node *) linitial(cref->fields);
475 Node *field2 = (Node *) lsecond(cref->fields);
476 char *name1;
477 char *name2;
478
479 Assert(IsA(field1, String));
480 name1 = strVal(field1);
481
482 /* Whole-row reference? */
483 if (IsA(field2, A_Star))
484 {
485 node = transformWholeRowRef(pstate, NULL, name1,
486 cref->location);
487 break;
488 }
489
490 Assert(IsA(field2, String));
491 name2 = strVal(field2);
492
493 /* Try to identify as a once-qualified column */
494 node = qualifiedNameToVar(pstate, NULL, name1, name2, true,
495 cref->location);
496 if (node == NULL)
497 {
498 /*
499 * Not known as a column of any range-table entry, so try
500 * it as a function call. Here, we will create an
501 * implicit RTE for tables not already entered.
502 */
503 node = transformWholeRowRef(pstate, NULL, name1,
504 cref->location);
505 node = ParseFuncOrColumn(pstate,
506 list_make1(makeString(name2)),
507 list_make1(node),
508 false, false, false,
509 NULL, true, cref->location);
510 }
511 break;
512 }
513 case 3:
514 {
515 Node *field1 = (Node *) linitial(cref->fields);
516 Node *field2 = (Node *) lsecond(cref->fields);
517 Node *field3 = (Node *) lthird(cref->fields);
518 char *name1;
519 char *name2;
520 char *name3;
521
522 Assert(IsA(field1, String));
523 name1 = strVal(field1);
524 Assert(IsA(field2, String));
525 name2 = strVal(field2);
526
527 /* Whole-row reference? */
528 if (IsA(field3, A_Star))
529 {
530 node = transformWholeRowRef(pstate, name1, name2,
531 cref->location);
532 break;
533 }
534
535 Assert(IsA(field3, String));
536 name3 = strVal(field3);
537
538 /* Try to identify as a twice-qualified column */
539 node = qualifiedNameToVar(pstate, name1, name2, name3, true,
540 cref->location);
541 if (node == NULL)
542 {
543 /* Try it as a function call */
544 node = transformWholeRowRef(pstate, name1, name2,
545 cref->location);
546 node = ParseFuncOrColumn(pstate,
547 list_make1(makeString(name3)),
548 list_make1(node),
549 false, false, false,
550 NULL, true, cref->location);
551 }
552 break;
553 }
554 case 4:
555 {
556 Node *field1 = (Node *) linitial(cref->fields);
557 Node *field2 = (Node *) lsecond(cref->fields);
558 Node *field3 = (Node *) lthird(cref->fields);
559 Node *field4 = (Node *) lfourth(cref->fields);
560 char *name1;
561 char *name2;
562 char *name3;
563 char *name4;
564
565 Assert(IsA(field1, String));
566 name1 = strVal(field1);
567 Assert(IsA(field2, String));
568 name2 = strVal(field2);
569 Assert(IsA(field3, String));
570 name3 = strVal(field3);
571
572 /*
573 * We check the catalog name and then ignore it.
574 */
575 if (strcmp(name1, get_database_name(MyDatabaseId)) != 0)
576 ereport(ERROR,
577 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
578 errmsg("cross-database references are not implemented: %s",
579 NameListToString(cref->fields)),
580 parser_errposition(pstate, cref->location)));
581
582 /* Whole-row reference? */
583 if (IsA(field4, A_Star))
584 {
585 node = transformWholeRowRef(pstate, name2, name3,
586 cref->location);
587 break;
588 }
589
590 Assert(IsA(field4, String));
591 name4 = strVal(field4);
592
593 /* Try to identify as a twice-qualified column */
594 node = qualifiedNameToVar(pstate, name2, name3, name4, true,
595 cref->location);
596 if (node == NULL)
597 {
598 /* Try it as a function call */
599 node = transformWholeRowRef(pstate, name2, name3,
600 cref->location);
601 node = ParseFuncOrColumn(pstate,
602 list_make1(makeString(name4)),
603 list_make1(node),
604 false, false, false,
605 NULL, true, cref->location);
606 }
607 break;
608 }
609 default:
610 ereport(ERROR,
611 (errcode(ERRCODE_SYNTAX_ERROR),
612 errmsg("improper qualified name (too many dotted names): %s",
613 NameListToString(cref->fields)),
614 parser_errposition(pstate, cref->location)));
615 node = NULL; /* keep compiler quiet */
616 break;
617 }
618
619 return node;
620 }
621
622 /*
623 * Locate the parameter type info for the given parameter number, and
624 * return a pointer to it.
625 */
626 static Oid *
627 find_param_type(ParseState *pstate, int paramno, int location)
628 {
629 Oid *result;
630
631 /*
632 * Find topmost ParseState, which is where paramtype info lives.
633 */
634 while (pstate->parentParseState != NULL)
635 pstate = pstate->parentParseState;
636
637 /* Check parameter number is in range */
638 if (paramno <= 0) /* probably can't happen? */
639 ereport(ERROR,
640 (errcode(ERRCODE_UNDEFINED_PARAMETER),
641 errmsg("there is no parameter $%d", paramno),
642 parser_errposition(pstate, location)));
643 if (paramno > pstate->p_numparams)
644 {
645 if (!pstate->p_variableparams)
646 ereport(ERROR,
647 (errcode(ERRCODE_UNDEFINED_PARAMETER),
648 errmsg("there is no parameter $%d", paramno),
649 parser_errposition(pstate, location)));
650 /* Okay to enlarge param array */
651 if (pstate->p_paramtypes)
652 pstate->p_paramtypes = (Oid *) repalloc(pstate->p_paramtypes,
653 paramno * sizeof(Oid));
654 else
655 pstate->p_paramtypes = (Oid *) palloc(paramno * sizeof(Oid));
656 /* Zero out the previously-unreferenced slots */
657 MemSet(pstate->p_paramtypes + pstate->p_numparams,
658 0,
659 (paramno - pstate->p_numparams) * sizeof(Oid));
660 pstate->p_numparams = paramno;
661 }
662
663 result = &pstate->p_paramtypes[paramno - 1];
664
665 if (pstate->p_variableparams)
666 {
667 /* If not seen before, initialize to UNKNOWN type */
668 if (*result == InvalidOid)
669 *result = UNKNOWNOID;
670 }
671
672 return result;
673 }
674
675 static Node *
676 transformParamRef(ParseState *pstate, ParamRef *pref)
677 {
678 int paramno = pref->number;
679 Oid *pptype = find_param_type(pstate, paramno, pref->location);
680 Param *param;
681
682 param = makeNode(Param);
683 param->paramkind = PARAM_EXTERN;
684 param->paramid = paramno;
685 param->paramtype = *pptype;
686 param->paramtypmod = -1;
687 param->location = pref->location;
688
689 return (Node *) param;
690 }
691
692 /* Test whether an a_expr is a plain NULL constant or not */
693 static bool
694 exprIsNullConstant(Node *arg)
695 {
696 if (arg && IsA(arg, A_Const))
697 {
698 A_Const *con = (A_Const *) arg;
699
700 if (con->val.type == T_Null)
701 return true;
702 }
703 return false;
704 }
705
706 static Node *
707 transformAExprOp(ParseState *pstate, A_Expr *a)
708 {
709 Node *lexpr = a->lexpr;
710 Node *rexpr = a->rexpr;
711 Node *result;
712
713 /*
714 * Special-case "foo = NULL" and "NULL = foo" for compatibility with
715 * standards-broken products (like Microsoft's). Turn these into IS NULL
716 * exprs.
717 */
718 if (Transform_null_equals &&
719 list_length(a->name) == 1 &&
720 strcmp(strVal(linitial(a->name)), "=") == 0 &&
721 (exprIsNullConstant(lexpr) || exprIsNullConstant(rexpr)))
722 {
723 NullTest *n = makeNode(NullTest);
724
725 n->nulltesttype = IS_NULL;
726
727 if (exprIsNullConstant(lexpr))
728 n->arg = (Expr *) rexpr;
729 else
730 n->arg = (Expr *) lexpr;
731
732 result = transformExpr(pstate, (Node *) n);
733 }
734 else if (lexpr && IsA(lexpr, RowExpr) &&
735 rexpr && IsA(rexpr, SubLink) &&
736 ((SubLink *) rexpr)->subLinkType == EXPR_SUBLINK)
737 {
738 /*
739 * Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the
740 * grammar did this, but now that a row construct is allowed anywhere
741 * in expressions, it's easier to do it here.
742 */
743 SubLink *s = (SubLink *) rexpr;
744
745 s->subLinkType = ROWCOMPARE_SUBLINK;
746 s->testexpr = lexpr;
747 s->operName = a->name;
748 s->location = a->location;
749 result = transformExpr(pstate, (Node *) s);
750 }
751 else if (lexpr && IsA(lexpr, RowExpr) &&
752 rexpr && IsA(rexpr, RowExpr))
753 {
754 /* "row op row" */
755 lexpr = transformExpr(pstate, lexpr);
756 rexpr = transformExpr(pstate, rexpr);
757 Assert(IsA(lexpr, RowExpr));
758 Assert(IsA(rexpr, RowExpr));
759
760 result = make_row_comparison_op(pstate,
761 a->name,
762 ((RowExpr *) lexpr)->args,
763 ((RowExpr *) rexpr)->args,
764 a->location);
765 }
766 else
767 {
768 /* Ordinary scalar operator */
769 lexpr = transformExpr(pstate, lexpr);
770 rexpr = transformExpr(pstate, rexpr);
771
772 result = (Node *) make_op(pstate,
773 a->name,
774 lexpr,
775 rexpr,
776 a->location);
777 }
778
779 return result;
780 }
781
782 static Node *
783 transformAExprAnd(ParseState *pstate, A_Expr *a)
784 {
785 Node *lexpr = transformExpr(pstate, a->lexpr);
786 Node *rexpr = transformExpr(pstate, a->rexpr);
787
788 lexpr = coerce_to_boolean(pstate, lexpr, "AND");
789 rexpr = coerce_to_boolean(pstate, rexpr, "AND");
790
791 return (Node *) makeBoolExpr(AND_EXPR,
792 list_make2(lexpr, rexpr),
793 a->location);
794 }
795
796 static Node *
797 transformAExprOr(ParseState *pstate, A_Expr *a)
798 {
799 Node *lexpr = transformExpr(pstate, a->lexpr);
800 Node *rexpr = transformExpr(pstate, a->rexpr);
801
802 lexpr = coerce_to_boolean(pstate, lexpr, "OR");
803 rexpr = coerce_to_boolean(pstate, rexpr, "OR");
804
805 return (Node *) makeBoolExpr(OR_EXPR,
806 list_make2(lexpr, rexpr),
807 a->location);
808 }
809
810 static Node *
811 transformAExprNot(ParseState *pstate, A_Expr *a)
812 {
813 Node *rexpr = transformExpr(pstate, a->rexpr);
814
815 rexpr = coerce_to_boolean(pstate, rexpr, "NOT");
816
817 return (Node *) makeBoolExpr(NOT_EXPR,
818 list_make1(rexpr),
819 a->location);
820 }
821
822 static Node *
823 transformAExprOpAny(ParseState *pstate, A_Expr *a)
824 {
825 Node *lexpr = transformExpr(pstate, a->lexpr);
826 Node *rexpr = transformExpr(pstate, a->rexpr);
827
828 return (Node *) make_scalar_array_op(pstate,
829 a->name,
830 true,
831 lexpr,
832 rexpr,
833 a->location);
834 }
835
836 static Node *
837 transformAExprOpAll(ParseState *pstate, A_Expr *a)
838 {
839 Node *lexpr = transformExpr(pstate, a->lexpr);
840 Node *rexpr = transformExpr(pstate, a->rexpr);
841
842 return (Node *) make_scalar_array_op(pstate,
843 a->name,
844 false,
845 lexpr,
846 rexpr,
847 a->location);
848 }
849
850 static Node *
851 transformAExprDistinct(ParseState *pstate, A_Expr *a)
852 {
853 Node *lexpr = transformExpr(pstate, a->lexpr);
854 Node *rexpr = transformExpr(pstate, a->rexpr);
855
856 if (lexpr && IsA(lexpr, RowExpr) &&
857 rexpr && IsA(rexpr, RowExpr))
858 {
859 /* "row op row" */
860 return make_row_distinct_op(pstate, a->name,
861 (RowExpr *) lexpr,
862 (RowExpr *) rexpr,
863 a->location);
864 }
865 else
866 {
867 /* Ordinary scalar operator */
868 return (Node *) make_distinct_op(pstate,
869 a->name,
870 lexpr,
871 rexpr,
872 a->location);
873 }
874 }
875
876 static Node *
877 transformAExprNullIf(ParseState *pstate, A_Expr *a)
878 {
879 Node *lexpr = transformExpr(pstate, a->lexpr);
880 Node *rexpr = transformExpr(pstate, a->rexpr);
881 Node *result;
882
883 result = (Node *) make_op(pstate,
884 a->name,
885 lexpr,
886 rexpr,
887 a->location);
888 if (((OpExpr *) result)->opresulttype != BOOLOID)
889 ereport(ERROR,
890 (errcode(ERRCODE_DATATYPE_MISMATCH),
891 errmsg("NULLIF requires = operator to yield boolean"),
892 parser_errposition(pstate, a->location)));
893
894 /*
895 * We rely on NullIfExpr and OpExpr being the same struct
896 */
897 NodeSetTag(result, T_NullIfExpr);
898
899 return result;
900 }
901
902 static Node *
903 transformAExprOf(ParseState *pstate, A_Expr *a)
904 {
905 /*
906 * Checking an expression for match to a list of type names. Will result
907 * in a boolean constant node.
908 */
909 Node *lexpr = transformExpr(pstate, a->lexpr);
910 Const *result;
911 ListCell *telem;
912 Oid ltype,
913 rtype;
914 bool matched = false;
915
916 ltype = exprType(lexpr);
917 foreach(telem, (List *) a->rexpr)
918 {
919 rtype = typenameTypeId(pstate, lfirst(telem), NULL);
920 matched = (rtype == ltype);
921 if (matched)
922 break;
923 }
924
925 /*
926 * We have two forms: equals or not equals. Flip the sense of the result
927 * for not equals.
928 */
929 if (strcmp(strVal(linitial(a->name)), "<>") == 0)
930 matched = (!matched);
931
932 result = (Const *) makeBoolConst(matched, false);
933
934 /* Make the result have the original input's parse location */
935 result->location = exprLocation((Node *) a);
936
937 return (Node *) result;
938 }
939
940 static Node *
941 transformAExprIn(ParseState *pstate, A_Expr *a)
942 {
943 Node *result = NULL;
944 Node *lexpr;
945 List *rexprs;
946 List *rvars;
947 List *rnonvars;
948 bool useOr;
949 bool haveRowExpr;
950 ListCell *l;
951
952 /*
953 * If the operator is <>, combine with AND not OR.
954 */
955 if (strcmp(strVal(linitial(a->name)), "<>") == 0)
956 useOr = false;
957 else
958 useOr = true;
959
960 /*
961 * We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
962 * possible if the inputs are all scalars (no RowExprs) and there is a
963 * suitable array type available. If not, we fall back to a boolean
964 * condition tree with multiple copies of the lefthand expression. Also,
965 * any IN-list items that contain Vars are handled as separate boolean
966 * conditions, because that gives the planner more scope for optimization
967 * on such clauses.
968 *
969 * First step: transform all the inputs, and detect whether any are
970 * RowExprs or contain Vars.
971 */
972 lexpr = transformExpr(pstate, a->lexpr);
973 haveRowExpr = (lexpr && IsA(lexpr, RowExpr));
974 rexprs = rvars = rnonvars = NIL;
975 foreach(l, (List *) a->rexpr)
976 {
977 Node *rexpr = transformExpr(pstate, lfirst(l));
978
979 haveRowExpr |= (rexpr && IsA(rexpr, RowExpr));
980 rexprs = lappend(rexprs, rexpr);
981 if (contain_vars_of_level(rexpr, 0))
982 rvars = lappend(rvars, rexpr);
983 else
984 rnonvars = lappend(rnonvars, rexpr);
985 }
986
987 /*
988 * ScalarArrayOpExpr is only going to be useful if there's more than one
989 * non-Var righthand item. Also, it won't work for RowExprs.
990 */
991 if (!haveRowExpr && list_length(rnonvars) > 1)
992 {
993 List *allexprs;
994 Oid scalar_type;
995 Oid array_type;
996
997 /*
998 * Try to select a common type for the array elements. Note that
999 * since the LHS' type is first in the list, it will be preferred when
1000 * there is doubt (eg, when all the RHS items are unknown literals).
1001 *
1002 * Note: use list_concat here not lcons, to avoid damaging rnonvars.
1003 */
1004 allexprs = list_concat(list_make1(lexpr), rnonvars);
1005 scalar_type = select_common_type(pstate, allexprs, NULL, NULL);
1006
1007 /* Do we have an array type to use? */
1008 if (OidIsValid(scalar_type))
1009 array_type = get_array_type(scalar_type);
1010 else
1011 array_type = InvalidOid;
1012 if (array_type != InvalidOid)
1013 {
1014 /*
1015 * OK: coerce all the right-hand non-Var inputs to the common type
1016 * and build an ArrayExpr for them.
1017 */
1018 List *aexprs;
1019 ArrayExpr *newa;
1020
1021 aexprs = NIL;
1022 foreach(l, rnonvars)
1023 {
1024 Node *rexpr = (Node *) lfirst(l);
1025
1026 rexpr = coerce_to_common_type(pstate, rexpr,
1027 scalar_type,
1028 "IN");
1029 aexprs = lappend(aexprs, rexpr);
1030 }
1031 newa = makeNode(ArrayExpr);
1032 newa->array_typeid = array_type;
1033 newa->element_typeid = scalar_type;
1034 newa->elements = aexprs;
1035 newa->multidims = false;
1036 newa->location = -1;
1037
1038 result = (Node *) make_scalar_array_op(pstate,
1039 a->name,
1040 useOr,
1041 lexpr,
1042 (Node *) newa,
1043 a->location);
1044
1045 /* Consider only the Vars (if any) in the loop below */
1046 rexprs = rvars;
1047 }
1048 }
1049
1050 /*
1051 * Must do it the hard way, ie, with a boolean expression tree.
1052 */
1053 foreach(l, rexprs)
1054 {
1055 Node *rexpr = (Node *) lfirst(l);
1056 Node *cmp;
1057
1058 if (haveRowExpr)
1059 {
1060 if (!IsA(lexpr, RowExpr) ||
1061 !IsA(rexpr, RowExpr))
1062 ereport(ERROR,
1063 (errcode(ERRCODE_SYNTAX_ERROR),
1064 errmsg("arguments of row IN must all be row expressions"),
1065 parser_errposition(pstate, a->location)));
1066 cmp = make_row_comparison_op(pstate,
1067 a->name,
1068 (List *) copyObject(((RowExpr *) lexpr)->args),
1069 ((RowExpr *) rexpr)->args,
1070 a->location);
1071 }
1072 else
1073 cmp = (Node *) make_op(pstate,
1074 a->name,
1075 copyObject(lexpr),
1076 rexpr,
1077 a->location);
1078
1079 cmp = coerce_to_boolean(pstate, cmp, "IN");
1080 if (result == NULL)
1081 result = cmp;
1082 else
1083 result = (Node *) makeBoolExpr(useOr ? OR_EXPR : AND_EXPR,
1084 list_make2(result, cmp),
1085 a->location);
1086 }
1087
1088 return result;
1089 }
1090
1091 static Node *
1092 transformFuncCall(ParseState *pstate, FuncCall *fn)
1093 {
1094 List *targs;
1095 ListCell *args;
1096
1097 /* Transform the list of arguments ... */
1098 targs = NIL;
1099 foreach(args, fn->args)
1100 {
1101 targs = lappend(targs, transformExpr(pstate,
1102 (Node *) lfirst(args)));
1103 }
1104
1105 /* ... and hand off to ParseFuncOrColumn */
1106 return ParseFuncOrColumn(pstate,
1107 fn->funcname,
1108 targs,
1109 fn->agg_star,
1110 fn->agg_distinct,
1111 fn->func_variadic,
1112 fn->over,
1113 false,
1114 fn->location);
1115 }
1116
1117 static Node *
1118 transformCaseExpr(ParseState *pstate, CaseExpr *c)
1119 {
1120 CaseExpr *newc;
1121 Node *arg;
1122 CaseTestExpr *placeholder;
1123 List *newargs;
1124 List *resultexprs;
1125 ListCell *l;
1126 Node *defresult;
1127 Oid ptype;
1128
1129 /* If we already transformed this node, do nothing */
1130 if (OidIsValid(c->casetype))
1131 return (Node *) c;
1132
1133 newc = makeNode(CaseExpr);
1134
1135 /* transform the test expression, if any */
1136 arg = transformExpr(pstate, (Node *) c->arg);
1137
1138 /* generate placeholder for test expression */
1139 if (arg)
1140 {
1141 /*
1142 * If test expression is an untyped literal, force it to text. We have
1143 * to do something now because we won't be able to do this coercion on
1144 * the placeholder. This is not as flexible as what was done in 7.4
1145 * and before, but it's good enough to handle the sort of silly coding
1146 * commonly seen.
1147 */
1148 if (exprType(arg) == UNKNOWNOID)
1149 arg = coerce_to_common_type(pstate, arg, TEXTOID, "CASE");
1150
1151 placeholder = makeNode(CaseTestExpr);
1152 placeholder->typeId = exprType(arg);
1153 placeholder->typeMod = exprTypmod(arg);
1154 }
1155 else
1156 placeholder = NULL;
1157
1158 newc->arg = (Expr *) arg;
1159
1160 /* transform the list of arguments */
1161 newargs = NIL;
1162 resultexprs = NIL;
1163 foreach(l, c->args)
1164 {
1165 CaseWhen *w = (CaseWhen *) lfirst(l);
1166 CaseWhen *neww = makeNode(CaseWhen);
1167 Node *warg;
1168
1169 Assert(IsA(w, CaseWhen));
1170
1171 warg = (Node *) w->expr;
1172 if (placeholder)
1173 {
1174 /* shorthand form was specified, so expand... */
1175 warg = (Node *) makeSimpleA_Expr(AEXPR_OP, "=",
1176 (Node *) placeholder,
1177 warg,
1178 w->location);
1179 }
1180 neww->expr = (Expr *) transformExpr(pstate, warg);
1181
1182 neww->expr = (Expr *) coerce_to_boolean(pstate,
1183 (Node *) neww->expr,
1184 "CASE/WHEN");
1185
1186 warg = (Node *) w->result;
1187 neww->result = (Expr *) transformExpr(pstate, warg);
1188 neww->location = w->location;
1189
1190 newargs = lappend(newargs, neww);
1191 resultexprs = lappend(resultexprs, neww->result);
1192 }
1193
1194 newc->args = newargs;
1195
1196 /* transform the default clause */
1197 defresult = (Node *) c->defresult;
1198 if (defresult == NULL)
1199 {
1200 A_Const *n = makeNode(A_Const);
1201
1202 n->val.type = T_Null;
1203 n->location = -1;
1204 defresult = (Node *) n;
1205 }
1206 newc->defresult = (Expr *) transformExpr(pstate, defresult);
1207
1208 /*
1209 * Note: default result is considered the most significant type in
1210 * determining preferred type. This is how the code worked before, but it
1211 * seems a little bogus to me --- tgl
1212 */
1213 resultexprs = lcons(newc->defresult, resultexprs);
1214
1215 ptype = select_common_type(pstate, resultexprs, "CASE", NULL);
1216 Assert(OidIsValid(ptype));
1217 newc->casetype = ptype;
1218
1219 /* Convert default result clause, if necessary */
1220 newc->defresult = (Expr *)
1221 coerce_to_common_type(pstate,
1222 (Node *) newc->defresult,
1223 ptype,
1224 "CASE/ELSE");
1225
1226 /* Convert when-clause results, if necessary */
1227 foreach(l, newc->args)
1228 {
1229 CaseWhen *w = (CaseWhen *) lfirst(l);
1230
1231 w->result = (Expr *)
1232 coerce_to_common_type(pstate,
1233 (Node *) w->result,
1234 ptype,
1235 "CASE/WHEN");
1236 }
1237
1238 newc->location = c->location;
1239
1240 return (Node *) newc;
1241 }
1242
1243 static Node *
1244 transformSubLink(ParseState *pstate, SubLink *sublink)
1245 {
1246 Node *result = (Node *) sublink;
1247 Query *qtree;
1248
1249 /* If we already transformed this node, do nothing */
1250 if (IsA(sublink->subselect, Query))
1251 return result;
1252
1253 pstate->p_hasSubLinks = true;
1254 qtree = parse_sub_analyze(sublink->subselect, pstate);
1255
1256 /*
1257 * Check that we got something reasonable. Many of these conditions are
1258 * impossible given restrictions of the grammar, but check 'em anyway.
1259 */
1260 if (!IsA(qtree, Query) ||
1261 qtree->commandType != CMD_SELECT ||
1262 qtree->utilityStmt != NULL)
1263 elog(ERROR, "unexpected non-SELECT command in SubLink");
1264 if (qtree->intoClause)
1265 ereport(ERROR,
1266 (errcode(ERRCODE_SYNTAX_ERROR),
1267 errmsg("subquery cannot have SELECT INTO"),
1268 parser_errposition(pstate,
1269 exprLocation((Node *) qtree->intoClause))));
1270
1271 sublink->subselect = (Node *) qtree;
1272
1273 if (sublink->subLinkType == EXISTS_SUBLINK)
1274 {
1275 /*
1276 * EXISTS needs no test expression or combining operator. These fields
1277 * should be null already, but make sure.
1278 */
1279 sublink->testexpr = NULL;
1280 sublink->operName = NIL;
1281 }
1282 else if (sublink->subLinkType == EXPR_SUBLINK ||
1283 sublink->subLinkType == ARRAY_SUBLINK)
1284 {
1285 ListCell *tlist_item = list_head(qtree->targetList);
1286
1287 /*
1288 * Make sure the subselect delivers a single column (ignoring resjunk
1289 * targets).
1290 */
1291 if (tlist_item == NULL ||
1292 ((TargetEntry *) lfirst(tlist_item))->resjunk)
1293 ereport(ERROR,
1294 (errcode(ERRCODE_SYNTAX_ERROR),
1295 errmsg("subquery must return a column"),
1296 parser_errposition(pstate, sublink->location)));
1297 while ((tlist_item = lnext(tlist_item)) != NULL)
1298 {
1299 if (!((TargetEntry *) lfirst(tlist_item))->resjunk)
1300 ereport(ERROR,
1301 (errcode(ERRCODE_SYNTAX_ERROR),
1302 errmsg("subquery must return only one column"),
1303 parser_errposition(pstate, sublink->location)));
1304 }
1305
1306 /*
1307 * EXPR and ARRAY need no test expression or combining operator. These
1308 * fields should be null already, but make sure.
1309 */
1310 sublink->testexpr = NULL;
1311 sublink->operName = NIL;
1312 }
1313 else
1314 {
1315 /* ALL, ANY, or ROWCOMPARE: generate row-comparing expression */
1316 Node *lefthand;
1317 List *left_list;
1318 List *right_list;
1319 ListCell *l;
1320
1321 /*
1322 * Transform lefthand expression, and convert to a list
1323 */
1324 lefthand = transformExpr(pstate, sublink->testexpr);
1325 if (lefthand && IsA(lefthand, RowExpr))
1326 left_list = ((RowExpr *) lefthand)->args;
1327 else
1328 left_list = list_make1(lefthand);
1329
1330 /*
1331 * Build a list of PARAM_SUBLINK nodes representing the output columns
1332 * of the subquery.
1333 */
1334 right_list = NIL;
1335 foreach(l, qtree->targetList)
1336 {
1337 TargetEntry *tent = (TargetEntry *) lfirst(l);
1338 Param *param;
1339
1340 if (tent->resjunk)
1341 continue;
1342
1343 param = makeNode(Param);
1344 param->paramkind = PARAM_SUBLINK;
1345 param->paramid = tent->resno;
1346 param->paramtype = exprType((Node *) tent->expr);
1347 param->paramtypmod = exprTypmod((Node *) tent->expr);
1348 param->location = -1;
1349
1350 right_list = lappend(right_list, param);
1351 }
1352
1353 /*
1354 * We could rely on make_row_comparison_op to complain if the list
1355 * lengths differ, but we prefer to generate a more specific error
1356 * message.
1357 */
1358 if (list_length(left_list) < list_length(right_list))
1359 ereport(ERROR,
1360 (errcode(ERRCODE_SYNTAX_ERROR),
1361 errmsg("subquery has too many columns"),
1362 parser_errposition(pstate, sublink->location)));
1363 if (list_length(left_list) > list_length(right_list))
1364 ereport(ERROR,
1365 (errcode(ERRCODE_SYNTAX_ERROR),
1366 errmsg("subquery has too few columns"),
1367 parser_errposition(pstate, sublink->location)));
1368
1369 /*
1370 * Identify the combining operator(s) and generate a suitable
1371 * row-comparison expression.
1372 */
1373 sublink->testexpr = make_row_comparison_op(pstate,
1374 sublink->operName,
1375 left_list,
1376 right_list,
1377 sublink->location);
1378 }
1379
1380 return result;
1381 }
1382
1383 /*
1384 * transformArrayExpr
1385 *
1386 * If the caller specifies the target type, the resulting array will
1387 * be of exactly that type. Otherwise we try to infer a common type
1388 * for the elements using select_common_type().
1389 */
1390 static Node *
1391 transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
1392 Oid array_type, Oid element_type, int32 typmod)
1393 {
1394 ArrayExpr *newa = makeNode(ArrayExpr);
1395 List *newelems = NIL;
1396 List *newcoercedelems = NIL;
1397 ListCell *element;
1398 Oid coerce_type;
1399 bool coerce_hard;
1400
1401 /*
1402 * Transform the element expressions
1403 *
1404 * Assume that the array is one-dimensional unless we find an array-type
1405 * element expression.
1406 */
1407 newa->multidims = false;
1408 foreach(element, a->elements)
1409 {
1410 Node *e = (Node *) lfirst(element);
1411 Node *newe;
1412
1413 /*
1414 * If an element is itself an A_ArrayExpr, recurse directly so that we
1415 * can pass down any target type we were given.
1416 */
1417 if (IsA(e, A_ArrayExpr))
1418 {
1419 newe = transformArrayExpr(pstate,
1420 (A_ArrayExpr *) e,
1421 array_type,
1422 element_type,
1423 typmod);
1424 /* we certainly have an array here */
1425 Assert(array_type == InvalidOid || array_type == exprType(newe));
1426 newa->multidims = true;
1427 }
1428 else
1429 {
1430 newe = transformExpr(pstate, e);
1431
1432 /*
1433 * Check for sub-array expressions, if we haven't already found
1434 * one.
1435 */
1436 if (!newa->multidims && type_is_array(exprType(newe)))
1437 newa->multidims = true;
1438 }
1439
1440 newelems = lappend(newelems, newe);
1441 }
1442
1443 /*
1444 * Select a target type for the elements.
1445 *
1446 * If we haven't been given a target array type, we must try to deduce a
1447 * common type based on the types of the individual elements present.
1448 */
1449 if (OidIsValid(array_type))
1450 {
1451 /* Caller must ensure array_type matches element_type */
1452 Assert(OidIsValid(element_type));
1453 coerce_type = (newa->multidims ? array_type : element_type);
1454 coerce_hard = true;
1455 }
1456 else
1457 {
1458 /* Can't handle an empty array without a target type */
1459 if (newelems == NIL)
1460 ereport(ERROR,
1461 (errcode(ERRCODE_INDETERMINATE_DATATYPE),
1462 errmsg("cannot determine type of empty array"),
1463 errhint("Explicitly cast to the desired type, "
1464 "for example ARRAY[]::integer[]."),
1465 parser_errposition(pstate, a->location)));
1466
1467 /* Select a common type for the elements */
1468 coerce_type = select_common_type(pstate, newelems, "ARRAY", NULL);
1469
1470 if (newa->multidims)
1471 {
1472 array_type = coerce_type;
1473 element_type = get_element_type(array_type);
1474 if (!OidIsValid(element_type))
1475 ereport(ERROR,
1476 (errcode(ERRCODE_UNDEFINED_OBJECT),
1477 errmsg("could not find element type for data type %s",
1478 format_type_be(array_type)),
1479 parser_errposition(pstate, a->location)));
1480 }
1481 else
1482 {
1483 element_type = coerce_type;
1484 array_type = get_array_type(element_type);
1485 if (!OidIsValid(array_type))
1486 ereport(ERROR,
1487 (errcode(ERRCODE_UNDEFINED_OBJECT),
1488 errmsg("could not find array type for data type %s",
1489 format_type_be(element_type)),
1490 parser_errposition(pstate, a->location)));
1491 }
1492 coerce_hard = false;
1493 }
1494
1495 /*
1496 * Coerce elements to target type
1497 *
1498 * If the array has been explicitly cast, then the elements are in turn
1499 * explicitly coerced.
1500 *
1501 * If the array's type was merely derived from the common type of its
1502 * elements, then the elements are implicitly coerced to the common type.
1503 * This is consistent with other uses of select_common_type().
1504 */
1505 foreach(element, newelems)
1506 {
1507 Node *e = (Node *) lfirst(element);
1508 Node *newe;
1509
1510 if (coerce_hard)
1511 {
1512 newe = coerce_to_target_type(pstate, e,
1513 exprType(e),
1514 coerce_type,
1515 typmod,
1516 COERCION_EXPLICIT,
1517 COERCE_EXPLICIT_CAST,
1518 -1);
1519 if (newe == NULL)
1520 ereport(ERROR,
1521 (errcode(ERRCODE_CANNOT_COERCE),
1522 errmsg("cannot cast type %s to %s",
1523 format_type_be(exprType(e)),
1524 format_type_be(coerce_type)),
1525 parser_errposition(pstate, exprLocation(e))));
1526 }
1527 else
1528 newe = coerce_to_common_type(pstate, e,
1529 coerce_type,
1530 "ARRAY");
1531 newcoercedelems = lappend(newcoercedelems, newe);
1532 }
1533
1534 newa->array_typeid = array_type;
1535 newa->element_typeid = element_type;
1536 newa->elements = newcoercedelems;
1537 newa->location = a->location;
1538
1539 return (Node *) newa;
1540 }
1541
1542 static Node *
1543 transformRowExpr(ParseState *pstate, RowExpr *r)
1544 {
1545 RowExpr *newr = makeNode(RowExpr);
1546
1547 /* Transform the field expressions */
1548 newr->args = transformExpressionList(pstate, r->args);
1549
1550 /* Barring later casting, we consider the type RECORD */
1551 newr->row_typeid = RECORDOID;
1552 newr->row_format = COERCE_IMPLICIT_CAST;
1553 newr->colnames = NIL; /* ROW() has anonymous columns */
1554 newr->location = r->location;
1555
1556 return (Node *) newr;
1557 }
1558
1559 static Node *
1560 transformCoalesceExpr(ParseState *pstate, CoalesceExpr *c)
1561 {
1562 CoalesceExpr *newc = makeNode(CoalesceExpr);
1563 List *newargs = NIL;
1564 List *newcoercedargs = NIL;
1565 ListCell *args;
1566
1567 foreach(args, c->args)
1568 {
1569 Node *e = (Node *) lfirst(args);
1570 Node *newe;
1571
1572 newe = transformExpr(pstate, e);
1573 newargs = lappend(newargs, newe);
1574 }
1575
1576 newc->coalescetype = select_common_type(pstate, newargs, "COALESCE", NULL);
1577
1578 /* Convert arguments if necessary */
1579 foreach(args, newargs)
1580 {
1581 Node *e = (Node *) lfirst(args);
1582 Node *newe;
1583
1584 newe = coerce_to_common_type(pstate, e,
1585 newc->coalescetype,
1586 "COALESCE");
1587 newcoercedargs = lappend(newcoercedargs, newe);
1588 }
1589
1590 newc->args = newcoercedargs;
1591 newc->location = c->location;
1592 return (Node *) newc;
1593 }
1594
1595 static Node *
1596 transformMinMaxExpr(ParseState *pstate, MinMaxExpr *m)
1597 {
1598 MinMaxExpr *newm = makeNode(MinMaxExpr);
1599 List *newargs = NIL;
1600 List *newcoercedargs = NIL;
1601 const char *funcname = (m->op == IS_GREATEST) ? "GREATEST" : "LEAST";
1602 ListCell *args;
1603
1604 newm->op = m->op;
1605 foreach(args, m->args)
1606 {
1607 Node *e = (Node *) lfirst(args);
1608 Node *newe;
1609
1610 newe = transformExpr(pstate, e);
1611 newargs = lappend(newargs, newe);
1612 }
1613
1614 newm->minmaxtype = select_common_type(pstate, newargs, funcname, NULL);
1615
1616 /* Convert arguments if necessary */
1617 foreach(args, newargs)
1618 {
1619 Node *e = (Node *) lfirst(args);
1620 Node *newe;
1621
1622 newe = coerce_to_common_type(pstate, e,
1623 newm->minmaxtype,
1624 funcname);
1625 newcoercedargs = lappend(newcoercedargs, newe);
1626 }
1627
1628 newm->args = newcoercedargs;
1629 newm->location = m->location;
1630 return (Node *) newm;
1631 }
1632
1633 static Node *
1634 transformXmlExpr(ParseState *pstate, XmlExpr *x)
1635 {
1636 XmlExpr *newx = makeNode(XmlExpr);
1637 ListCell *lc;
1638 int i;
1639
1640 newx->op = x->op;
1641 if (x->name)
1642 newx->name = map_sql_identifier_to_xml_name(x->name, false, false);
1643 else
1644 newx->name = NULL;
1645 newx->xmloption = x->xmloption;
1646 newx->location = x->location;
1647
1648 /*
1649 * gram.y built the named args as a list of ResTarget. Transform each,
1650 * and break the names out as a separate list.
1651 */
1652 newx->named_args = NIL;
1653 newx->arg_names = NIL;
1654
1655 foreach(lc, x->named_args)
1656 {
1657 ResTarget *r = (ResTarget *) lfirst(lc);
1658 Node *expr;
1659 char *argname;
1660
1661 Assert(IsA(r, ResTarget));
1662
1663 expr = transformExpr(pstate, r->val);
1664
1665 if (r->name)
1666 argname = map_sql_identifier_to_xml_name(r->name, false, false);
1667 else if (IsA(r->val, ColumnRef))
1668 argname = map_sql_identifier_to_xml_name(FigureColname(r->val),
1669 true, false);
1670 else
1671 {
1672 ereport(ERROR,
1673 (errcode(ERRCODE_SYNTAX_ERROR),
1674 x->op == IS_XMLELEMENT
1675 ? errmsg("unnamed XML attribute value must be a column reference")
1676 : errmsg("unnamed XML element value must be a column reference"),
1677 parser_errposition(pstate, r->location)));
1678 argname = NULL; /* keep compiler quiet */
1679 }
1680
1681 /* reject duplicate argnames in XMLELEMENT only */
1682 if (x->op == IS_XMLELEMENT)
1683 {
1684 ListCell *lc2;
1685
1686 foreach(lc2, newx->arg_names)
1687 {
1688 if (strcmp(argname, strVal(lfirst(lc2))) == 0)
1689 ereport(ERROR,
1690 (errcode(ERRCODE_SYNTAX_ERROR),
1691 errmsg("XML attribute name \"%s\" appears more than once",
1692 argname),
1693 parser_errposition(pstate, r->location)));
1694 }
1695 }
1696
1697 newx->named_args = lappend(newx->named_args, expr);
1698 newx->arg_names = lappend(newx->arg_names, makeString(argname));
1699 }
1700
1701 /* The other arguments are of varying types depending on the function */
1702 newx->args = NIL;
1703 i = 0;
1704 foreach(lc, x->args)
1705 {
1706 Node *e = (Node *) lfirst(lc);
1707 Node *newe;
1708
1709 newe = transformExpr(pstate, e);
1710 switch (x->op)
1711 {
1712 case IS_XMLCONCAT:
1713 newe = coerce_to_specific_type(pstate, newe, XMLOID,
1714 "XMLCONCAT");
1715 break;
1716 case IS_XMLELEMENT:
1717 /* no coercion necessary */
1718 break;
1719 case IS_XMLFOREST:
1720 newe = coerce_to_specific_type(pstate, newe, XMLOID,
1721 "XMLFOREST");
1722 break;
1723 case IS_XMLPARSE:
1724 if (i == 0)
1725 newe = coerce_to_specific_type(pstate, newe, TEXTOID,
1726 "XMLPARSE");
1727 else
1728 newe = coerce_to_boolean(pstate, newe, "XMLPARSE");
1729 break;
1730 case IS_XMLPI:
1731 newe = coerce_to_specific_type(pstate, newe, TEXTOID,
1732 "XMLPI");
1733 break;
1734 case IS_XMLROOT:
1735 if (i == 0)
1736 newe = coerce_to_specific_type(pstate, newe, XMLOID,
1737 "XMLROOT");
1738 else if (i == 1)
1739 newe = coerce_to_specific_type(pstate, newe, TEXTOID,
1740 "XMLROOT");
1741 else
1742 newe = coerce_to_specific_type(pstate, newe, INT4OID,
1743 "XMLROOT");
1744 break;
1745 case IS_XMLSERIALIZE:
1746 /* not handled here */
1747 Assert(false);
1748 break;
1749 case IS_DOCUMENT:
1750 newe = coerce_to_specific_type(pstate, newe, XMLOID,
1751 "IS DOCUMENT");
1752 break;
1753 }
1754 newx->args = lappend(newx->args, newe);
1755 i++;
1756 }
1757
1758 return (Node *) newx;
1759 }
1760
1761 static Node *
1762 transformXmlSerialize(ParseState *pstate, XmlSerialize *xs)
1763 {
1764 Node *result;
1765 XmlExpr *xexpr;
1766 Oid targetType;
1767 int32 targetTypmod;
1768
1769 xexpr = makeNode(XmlExpr);
1770 xexpr->op = IS_XMLSERIALIZE;
1771 xexpr->args = list_make1(coerce_to_specific_type(pstate,
1772 transformExpr(pstate, xs->expr),
1773 XMLOID,
1774 "XMLSERIALIZE"));
1775
1776 targetType = typenameTypeId(pstate, xs->typename, &targetTypmod);
1777
1778 xexpr->xmloption = xs->xmloption;
1779 xexpr->location = xs->location;
1780 /* We actually only need these to be able to parse back the expression. */
1781 xexpr->type = targetType;
1782 xexpr->typmod = targetTypmod;
1783
1784 /*
1785 * The actual target type is determined this way. SQL allows char and
1786 * varchar as target types. We allow anything that can be cast implicitly
1787 * from text. This way, user-defined text-like data types automatically
1788 * fit in.
1789 */
1790 result = coerce_to_target_type(pstate, (Node *) xexpr,
1791 TEXTOID, targetType, targetTypmod,
1792 COERCION_IMPLICIT,
1793 COERCE_IMPLICIT_CAST,
1794 -1);
1795 if (result == NULL)
1796 ereport(ERROR,
1797 (errcode(ERRCODE_CANNOT_COERCE),
1798 errmsg("cannot cast XMLSERIALIZE result to %s",
1799 format_type_be(targetType)),
1800 parser_errposition(pstate, xexpr->location)));
1801 return result;
1802 }
1803
1804 static Node *
1805 transformBooleanTest(ParseState *pstate, BooleanTest *b)
1806 {
1807 const char *clausename;
1808
1809 switch (b->booltesttype)
1810 {
1811 case IS_TRUE:
1812 clausename = "IS TRUE";
1813 break;
1814 case IS_NOT_TRUE:
1815 clausename = "IS NOT TRUE";
1816 break;
1817 case IS_FALSE:
1818 clausename = "IS FALSE";
1819 break;
1820 case IS_NOT_FALSE:
1821 clausename = "IS NOT FALSE";
1822 break;
1823 case IS_UNKNOWN:
1824 clausename = "IS UNKNOWN";
1825 break;
1826 case IS_NOT_UNKNOWN:
1827 clausename = "IS NOT UNKNOWN";
1828 break;
1829 default:
1830 elog(ERROR, "unrecognized booltesttype: %d",
1831 (int) b->booltesttype);
1832 clausename = NULL; /* keep compiler quiet */
1833 }
1834
1835 b->arg = (Expr *) transformExpr(pstate, (Node *) b->arg);
1836
1837 b->arg = (Expr *) coerce_to_boolean(pstate,
1838 (Node *) b->arg,
1839 clausename);
1840
1841 return (Node *) b;
1842 }
1843
1844 static Node *
1845 transformCurrentOfExpr(ParseState *pstate, CurrentOfExpr *cexpr)
1846 {
1847 int sublevels_up;
1848
1849 /* CURRENT OF can only appear at top level of UPDATE/DELETE */
1850 Assert(pstate->p_target_rangetblentry != NULL);
1851 cexpr->cvarno = RTERangeTablePosn(pstate,
1852 pstate->p_target_rangetblentry,
1853 &sublevels_up);
1854 Assert(sublevels_up == 0);
1855
1856 /* If a parameter is used, it must be of type REFCURSOR */
1857 if (cexpr->cursor_name == NULL)
1858 {
1859 Oid *pptype = find_param_type(pstate, cexpr->cursor_param, -1);
1860
1861 if (pstate->p_variableparams && *pptype == UNKNOWNOID)
1862 {
1863 /* resolve unknown param type as REFCURSOR */
1864 *pptype = REFCURSOROID;
1865 }
1866 else if (*pptype != REFCURSOROID)
1867 {
1868 ereport(ERROR,
1869 (errcode(ERRCODE_AMBIGUOUS_PARAMETER),
1870 errmsg("inconsistent types deduced for parameter $%d",
1871 cexpr->cursor_param),
1872 errdetail("%s versus %s",
1873 format_type_be(*pptype),
1874 format_type_be(REFCURSOROID))));
1875 }
1876 }
1877
1878 return (Node *) cexpr;
1879 }
1880
1881 /*
1882 * Construct a whole-row reference to represent the notation "relation.*".
1883 *
1884 * A whole-row reference is a Var with varno set to the correct range
1885 * table entry, and varattno == 0 to signal that it references the whole
1886 * tuple. (Use of zero here is unclean, since it could easily be confused
1887 * with error cases, but it's not worth changing now.) The vartype indicates
1888 * a rowtype; either a named composite type, or RECORD.
1889 */
1890 static Node *
1891 transformWholeRowRef(ParseState *pstate, char *schemaname, char *relname,
1892 int location)
1893 {
1894 Var *result;
1895 RangeTblEntry *rte;
1896 int vnum;
1897 int sublevels_up;
1898 Oid toid;
1899
1900 /* Look up the referenced RTE, creating it if needed */
1901
1902 rte = refnameRangeTblEntry(pstate, schemaname, relname, location,
1903 &sublevels_up);
1904
1905 if (rte == NULL)
1906 rte = addImplicitRTE(pstate,
1907 makeRangeVar(schemaname, relname, location));
1908
1909 vnum = RTERangeTablePosn(pstate, rte, &sublevels_up);
1910
1911 /* Build the appropriate referencing node */
1912
1913 switch (rte->rtekind)
1914 {
1915 case RTE_RELATION:
1916 /* relation: the rowtype is a named composite type */
1917 toid = get_rel_type_id(rte->relid);
1918 if (!OidIsValid(toid))
1919 elog(ERROR, "could not find type OID for relation %u",
1920 rte->relid);
1921 result = makeVar(vnum,
1922 InvalidAttrNumber,
1923 toid,
1924 -1,
1925 sublevels_up);
1926 break;
1927 case RTE_FUNCTION:
1928 toid = exprType(rte->funcexpr);
1929 if (type_is_rowtype(toid))
1930 {
1931 /* func returns composite; same as relation case */
1932 result = makeVar(vnum,
1933 InvalidAttrNumber,
1934 toid,
1935 -1,
1936 sublevels_up);
1937 }
1938 else
1939 {
1940 /*
1941 * func returns scalar; instead of making a whole-row Var,
1942 * just reference the function's scalar output. (XXX this
1943 * seems a tad inconsistent, especially if "f.*" was
1944 * explicitly written ...)
1945 */
1946 result = makeVar(vnum,
1947 1,
1948 toid,
1949 -1,
1950 sublevels_up);
1951 }
1952 break;
1953 case RTE_VALUES:
1954 toid = RECORDOID;
1955 /* returns composite; same as relation case */
1956 result = makeVar(vnum,
1957 InvalidAttrNumber,
1958 toid,
1959 -1,
1960 sublevels_up);
1961 break;
1962 default:
1963
1964 /*
1965 * RTE is a join or subselect. We represent this as a whole-row
1966 * Var of RECORD type. (Note that in most cases the Var will be
1967 * expanded to a RowExpr during planning, but that is not our
1968 * concern here.)
1969 */
1970 result = makeVar(vnum,
1971 InvalidAttrNumber,
1972 RECORDOID,
1973 -1,
1974 sublevels_up);
1975 break;
1976 }
1977
1978 /* location is not filled in by makeVar */
1979 result->location = location;
1980
1981 /* mark relation as requiring whole-row SELECT access */
1982 markVarForSelectPriv(pstate, result, rte);
1983
1984 return (Node *) result;
1985 }
1986
1987 /*
1988 * Handle an explicit CAST construct.
1989 *
1990 * Transform the argument, then look up the type name and apply any necessary
1991 * coercion function(s).
1992 */
1993 static Node *
1994 transformTypeCast(ParseState *pstate, TypeCast *tc)
1995 {
1996 Node *result;
1997 Node *expr = transformExpr(pstate, tc->arg);
1998 Oid inputType = exprType(expr);
1999 Oid targetType;
2000 int32 targetTypmod;
2001 int location;
2002
2003 targetType = typenameTypeId(pstate, tc->typename, &targetTypmod);
2004
2005 if (inputType == InvalidOid)
2006 return expr; /* do nothing if NULL input */
2007
2008 /*
2009 * Location of the coercion is preferentially the location of the :: or
2010 * CAST symbol, but if there is none then use the location of the type
2011 * name (this can happen in TypeName 'string' syntax, for instance).
2012 */
2013 location = tc->location;
2014 if (location < 0)
2015 location = tc->typename->location;
2016
2017 result = coerce_to_target_type(pstate, expr, inputType,
2018 targetType, targetTypmod,
2019 COERCION_EXPLICIT,
2020 COERCE_EXPLICIT_CAST,
2021 location);
2022 if (result == NULL)
2023 ereport(ERROR,
2024 (errcode(ERRCODE_CANNOT_COERCE),
2025 errmsg("cannot cast type %s to %s",
2026 format_type_be(inputType),
2027 format_type_be(targetType)),
2028 parser_coercion_errposition(pstate, location, expr)));
2029
2030 return result;
2031 }
2032
2033 /*
2034 * Transform a "row compare-op row" construct
2035 *
2036 * The inputs are lists of already-transformed expressions.
2037 * As with coerce_type, pstate may be NULL if no special unknown-Param
2038 * processing is wanted.
2039 *
2040 * The output may be a single OpExpr, an AND or OR combination of OpExprs,
2041 * or a RowCompareExpr. In all cases it is guaranteed to return boolean.
2042 * The AND, OR, and RowCompareExpr cases further imply things about the
2043 * behavior of the operators (ie, they behave as =, <>, or < <= > >=).
2044 */
2045 static Node *
2046 make_row_comparison_op(ParseState *pstate, List *opname,
2047 List *largs, List *rargs, int location)
2048 {
2049 RowCompareExpr *rcexpr;
2050 RowCompareType rctype;
2051 List *opexprs;
2052 List *opnos;
2053 List *opfamilies;
2054 ListCell *l,
2055 *r;
2056 List **opfamily_lists;
2057 List **opstrat_lists;
2058 Bitmapset *strats;
2059 int nopers;
2060 int i;
2061
2062 nopers = list_length(largs);
2063 if (nopers != list_length(rargs))
2064 ereport(ERROR,
2065 (errcode(ERRCODE_SYNTAX_ERROR),
2066 errmsg("unequal number of entries in row expressions"),
2067 parser_errposition(pstate, location)));
2068
2069 /*
2070 * We can't compare zero-length rows because there is no principled basis
2071 * for figuring out what the operator is.
2072 */
2073 if (nopers == 0)
2074 ereport(ERROR,
2075 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2076 errmsg("cannot compare rows of zero length"),
2077 parser_errposition(pstate, location)));
2078
2079 /*
2080 * Identify all the pairwise operators, using make_op so that behavior is
2081 * the same as in the simple scalar case.
2082 */
2083 opexprs = NIL;
2084 forboth(l, largs, r, rargs)
2085 {
2086 Node *larg = (Node *) lfirst(l);
2087 Node *rarg = (Node *) lfirst(r);
2088 OpExpr *cmp;
2089
2090 cmp = (OpExpr *) make_op(pstate, opname, larg, rarg, location);
2091 Assert(IsA(cmp, OpExpr));
2092
2093 /*
2094 * We don't use coerce_to_boolean here because we insist on the
2095 * operator yielding boolean directly, not via coercion. If it
2096 * doesn't yield bool it won't be in any index opfamilies...
2097 */
2098 if (cmp->opresulttype != BOOLOID)
2099 ereport(ERROR,
2100 (errcode(ERRCODE_DATATYPE_MISMATCH),
2101 errmsg("row comparison operator must yield type boolean, "
2102 "not type %s",
2103 format_type_be(cmp->opresulttype)),
2104 parser_errposition(pstate, location)));
2105 if (expression_returns_set((Node *) cmp))
2106 ereport(ERROR,
2107 (errcode(ERRCODE_DATATYPE_MISMATCH),
2108 errmsg("row comparison operator must not return a set"),
2109 parser_errposition(pstate, location)));
2110 opexprs = lappend(opexprs, cmp);
2111 }
2112
2113 /*
2114 * If rows are length 1, just return the single operator. In this case we
2115 * don't insist on identifying btree semantics for the operator (but we
2116 * still require it to return boolean).
2117 */
2118 if (nopers == 1)
2119 return (Node *) linitial(opexprs);
2120
2121 /*
2122 * Now we must determine which row comparison semantics (= <> < <= > >=)
2123 * apply to this set of operators. We look for btree opfamilies
2124 * containing the operators, and see which interpretations (strategy
2125 * numbers) exist for each operator.
2126 */
2127 opfamily_lists = (List **) palloc(nopers * sizeof(List *));
2128 opstrat_lists = (List **) palloc(nopers * sizeof(List *));
2129 strats = NULL;
2130 i = 0;
2131 foreach(l, opexprs)
2132 {
2133 Oid opno = ((OpExpr *) lfirst(l))->opno;
2134 Bitmapset *this_strats;
2135 ListCell *j;
2136
2137 get_op_btree_interpretation(opno,
2138 &opfamily_lists[i], &opstrat_lists[i]);
2139
2140 /*
2141 * convert strategy number list to a Bitmapset to make the
2142 * intersection calculation easy.
2143 */
2144 this_strats = NULL;
2145 foreach(j, opstrat_lists[i])
2146 {
2147 this_strats = bms_add_member(this_strats, lfirst_int(j));
2148 }
2149 if (i == 0)
2150 strats = this_strats;
2151 else
2152 strats = bms_int_members(strats, this_strats);
2153 i++;
2154 }
2155
2156 /*
2157 * If there are multiple common interpretations, we may use any one of
2158 * them ... this coding arbitrarily picks the lowest btree strategy
2159 * number.
2160 */
2161 i = bms_first_member(strats);
2162 if (i < 0)
2163 {
2164 /* No common interpretation, so fail */
2165 ereport(ERROR,
2166 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2167 errmsg("could not determine interpretation of row comparison operator %s",
2168 strVal(llast(opname))),
2169 errhint("Row comparison operators must be associated with btree operator families."),
2170 parser_errposition(pstate, location)));
2171 }
2172 rctype = (RowCompareType) i;
2173
2174 /*
2175 * For = and <> cases, we just combine the pairwise operators with AND or
2176 * OR respectively.
2177 *
2178 * Note: this is presently the only place where the parser generates
2179 * BoolExpr with more than two arguments. Should be OK since the rest of
2180 * the system thinks BoolExpr is N-argument anyway.
2181 */
2182 if (rctype == ROWCOMPARE_EQ)
2183 return (Node *) makeBoolExpr(AND_EXPR, opexprs, location);
2184 if (rctype == ROWCOMPARE_NE)
2185 return (Node *) makeBoolExpr(OR_EXPR, opexprs, location);
2186
2187 /*
2188 * Otherwise we need to choose exactly which opfamily to associate with
2189 * each operator.
2190 */
2191 opfamilies = NIL;
2192 for (i = 0; i < nopers; i++)
2193 {
2194 Oid opfamily = InvalidOid;
2195
2196 forboth(l, opfamily_lists[i], r, opstrat_lists[i])
2197 {
2198 int opstrat = lfirst_int(r);
2199
2200 if (opstrat == rctype)
2201 {
2202 opfamily = lfirst_oid(l);
2203 break;
2204 }
2205 }
2206 if (OidIsValid(opfamily))
2207 opfamilies = lappend_oid(opfamilies, opfamily);
2208 else /* should not happen */
2209 ereport(ERROR,
2210 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2211 errmsg("could not determine interpretation of row comparison operator %s",
2212 strVal(llast(opname))),
2213 errdetail("There are multiple equally-plausible candidates."),
2214 parser_errposition(pstate, location)));
2215 }
2216
2217 /*
2218 * Now deconstruct the OpExprs and create a RowCompareExpr.
2219 *
2220 * Note: can't just reuse the passed largs/rargs lists, because of
2221 * possibility that make_op inserted coercion operations.
2222 */
2223 opnos = NIL;
2224 largs = NIL;
2225 rargs = NIL;
2226 foreach(l, opexprs)
2227 {
2228 OpExpr *cmp = (OpExpr *) lfirst(l);
2229
2230 opnos = lappend_oid(opnos, cmp->opno);
2231 largs = lappend(largs, linitial(cmp->args));
2232 rargs = lappend(rargs, lsecond(cmp->args));
2233 }
2234
2235 rcexpr = makeNode(RowCompareExpr);
2236 rcexpr->rctype = rctype;
2237 rcexpr->opnos = opnos;
2238 rcexpr->opfamilies = opfamilies;
2239 rcexpr->largs = largs;
2240 rcexpr->rargs = rargs;
2241
2242 return (Node *) rcexpr;
2243 }
2244
2245 /*
2246 * Transform a "row IS DISTINCT FROM row" construct
2247 *
2248 * The input RowExprs are already transformed
2249 */
2250 static Node *
2251 make_row_distinct_op(ParseState *pstate, List *opname,
2252 RowExpr *lrow, RowExpr *rrow,
2253 int location)
2254 {
2255 Node *result = NULL;
2256 List *largs = lrow->args;
2257 List *rargs = rrow->args;
2258 ListCell *l,
2259 *r;
2260
2261 if (list_length(largs) != list_length(rargs))
2262 ereport(ERROR,
2263 (errcode(ERRCODE_SYNTAX_ERROR),
2264 errmsg("unequal number of entries in row expressions"),
2265 parser_errposition(pstate, location)));
2266
2267 forboth(l, largs, r, rargs)
2268 {
2269 Node *larg = (Node *) lfirst(l);
2270 Node *rarg = (Node *) lfirst(r);
2271 Node *cmp;
2272
2273 cmp = (Node *) make_distinct_op(pstate, opname, larg, rarg, location);
2274 if (result == NULL)
2275 result = cmp;
2276 else
2277 result = (Node *) makeBoolExpr(OR_EXPR,
2278 list_make2(result, cmp),
2279 location);
2280 }
2281
2282 if (result == NULL)
2283 {
2284 /* zero-length rows? Generate constant FALSE */
2285 result = makeBoolConst(false, false);
2286 }
2287
2288 return result;
2289 }
2290
2291 /*
2292 * make the node for an IS DISTINCT FROM operator
2293 */
2294 static Expr *
2295 make_distinct_op(ParseState *pstate, List *opname, Node *ltree, Node *rtree,
2296 int location)
2297 {
2298 Expr *result;
2299
2300 result = make_op(pstate, opname, ltree, rtree, location);
2301 if (((OpExpr *) result)->opresulttype != BOOLOID)
2302 ereport(ERROR,
2303 (errcode(ERRCODE_DATATYPE_MISMATCH),
2304 errmsg("IS DISTINCT FROM requires = operator to yield boolean"),
2305 parser_errposition(pstate, location)));
2306
2307 /*
2308 * We rely on DistinctExpr and OpExpr being same struct
2309 */
2310 NodeSetTag(result, T_DistinctExpr);
2311
2312 return result;
2313 }
PostgreSQL from CVS