| blob | bad1df732ea4de3df3e7ec623e6168072fdb8d70 |
1 /*-------------------------------------------------------------------------
2 *
3 * parse_expr.c
4 * handle expressions in parser
5 *
6 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 *
10 * IDENTIFICATION
11 * src/backend/parser/parse_expr.c
12 *
13 *-------------------------------------------------------------------------
14 */
43 /* GUC parameters */
98 JsonBehaviorType default_behavior,
111 /*
112 * transformExpr -
113 * Analyze and transform expressions. Type checking and type casting is
114 * done here. This processing converts the raw grammar output into
115 * expression trees with fully determined semantics.
116 */
117 Node *
119 {
121 ParseExprKind sv_expr_kind;
123 /* Save and restore identity of expression type we're parsing */
133 }
137 {
143 /* Guard against stack overflow due to overly complex expressions */
147 {
178 {
182 {
205 /* we can transform these just like AEXPR_OP */
218 }
220 }
244 {
250 }
286 {
290 /* the argument can be any type, so don't coerce it */
294 }
304 /*
305 * In all places where DEFAULT is legal, the caller should have
306 * processed it rather than passing it to transformExpr().
307 */
316 /*
317 * CaseTestExpr doesn't require any processing; it is only
318 * injected into parse trees in a fully-formed state.
319 *
320 * Ordinarily we should not see a Var here, but it is convenient
321 * for transformJoinUsingClause() to create untransformed operator
322 * trees containing already-transformed Vars. The best
323 * alternative would be to deconstruct and reconstruct column
324 * references, which seems expensively pointless. So allow it.
325 */
328 {
331 }
374 /* should not reach here */
378 }
381 }
383 /*
384 * helper routine for delivering "column does not exist" error message
385 *
386 * (Usually we don't have to work this hard, but the general case of field
387 * selection from an arbitrary node needs it.)
388 */
389 static void
392 {
397 {
398 /* Reference the RTE by alias not by actual table name */
407 }
408 else
409 {
410 /* Have to do it by reference to the type of the expression */
423 attname),
425 else
432 }
433 }
437 {
444 /*
445 * We have to split any field-selection operations apart from
446 * subscripting. Adjacent A_Indices nodes have to be treated as a single
447 * multidimensional subscript operation.
448 */
450 {
456 {
461 }
462 else
463 {
468 /* process subscripts before this field selection */
471 result,
474 subscripts,
481 last_srf,
482 NULL,
484 location);
488 }
489 }
490 /* process trailing subscripts, if any */
493 result,
496 subscripts,
500 }
502 /*
503 * Transform a ColumnRef.
504 *
505 * If you find yourself changing this code, see also ExpandColumnRefStar.
506 */
509 {
516 enum
517 {
518 CRERR_NO_COLUMN,
519 CRERR_NO_RTE,
520 CRERR_WRONG_DB,
521 CRERR_TOO_MANY
525 /*
526 * Check to see if the column reference is in an invalid place within the
527 * query. We allow column references in most places, except in default
528 * expressions and partition bound expressions.
529 */
532 {
578 /* okay */
588 /*
589 * There is intentionally no default: case here, so that the
590 * compiler will warn if we add a new ParseExprKind without
591 * extending this switch. If we do see an unrecognized value at
592 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
593 * which is sane anyway.
594 */
595 }
602 /*
603 * Give the PreParseColumnRefHook, if any, first shot. If it returns
604 * non-null then that's all, folks.
605 */
607 {
611 }
613 /*----------
614 * The allowed syntaxes are:
615 *
616 * A First try to resolve as unqualified column name;
617 * if no luck, try to resolve as unqualified table name (A.*).
618 * A.B A is an unqualified table name; B is either a
619 * column or function name (trying column name first).
620 * A.B.C schema A, table B, col or func name C.
621 * A.B.C.D catalog A, schema B, table C, col or func D.
622 * A.* A is an unqualified table name; means whole-row value.
623 * A.B.* whole-row value of table B in schema A.
624 * A.B.C.* whole-row value of table C in schema B in catalog A.
625 *
626 * We do not need to cope with bare "*"; that will only be accepted by
627 * the grammar at the top level of a SELECT list, and transformTargetList
628 * will take care of it before it ever gets here. Also, "A.*" etc will
629 * be expanded by transformTargetList if they appear at SELECT top level,
630 * so here we are only going to see them as function or operator inputs.
631 *
632 * Currently, if a catalog name is given then it must equal the current
633 * database name; we check it here and then discard it.
634 *----------
635 */
637 {
639 {
644 /* Try to identify as an unqualified column */
648 {
649 /*
650 * Not known as a column of any range-table entry.
651 *
652 * Try to find the name as a relation. Note that only
653 * relations already entered into the rangetable will be
654 * recognized.
655 *
656 * This is a hack for backwards compatibility with
657 * PostQUEL-inspired syntax. The preferred form now is
658 * "rel.*".
659 */
666 }
668 }
670 {
676 /* Locate the referenced nsitem */
681 {
684 }
686 /* Whole-row reference? */
688 {
692 }
696 /* Try to identify as a column of the nsitem */
700 {
701 /* Try it as a function call on the whole row */
708 NULL,
711 }
713 }
715 {
723 /* Locate the referenced nsitem */
728 {
731 }
733 /* Whole-row reference? */
735 {
739 }
743 /* Try to identify as a column of the nsitem */
747 {
748 /* Try it as a function call on the whole row */
755 NULL,
758 }
760 }
762 {
773 /*
774 * We check the catalog name and then ignore it.
775 */
777 {
780 }
782 /* Locate the referenced nsitem */
787 {
790 }
792 /* Whole-row reference? */
794 {
798 }
802 /* Try to identify as a column of the nsitem */
806 {
807 /* Try it as a function call on the whole row */
814 NULL,
817 }
819 }
823 }
825 /*
826 * Now give the PostParseColumnRefHook, if any, a chance. We pass the
827 * translation-so-far so that it can throw an error if it wishes in the
828 * case that it has a conflicting interpretation of the ColumnRef. (If it
829 * just translates anyway, we'll throw an error, because we can't undo
830 * whatever effects the preceding steps may have had on the pstate.) If it
831 * returns NULL, use the standard translation, or throw a suitable error
832 * if there is none.
833 */
835 {
847 }
849 /*
850 * Throw error if no translation found.
851 */
853 {
855 {
877 }
878 }
881 }
885 {
888 /*
889 * The core parser knows nothing about Params. If a hook is supplied,
890 * call it. If not, or if the hook returns NULL, throw a generic error.
891 */
894 else
904 }
906 /* Test whether an a_expr is a plain NULL constant or not */
907 static bool
909 {
911 {
916 }
918 }
922 {
927 /*
928 * Special-case "foo = NULL" and "NULL = foo" for compatibility with
929 * standards-broken products (like Microsoft's). Turn these into IS NULL
930 * exprs. (If either side is a CaseTestExpr, then the expression was
931 * generated internally from a CASE-WHEN expression, and
932 * transform_null_equals does not apply.)
933 */
939 {
947 else
951 }
955 {
956 /*
957 * Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the
958 * grammar did this, but now that a row construct is allowed anywhere
959 * in expressions, it's easier to do it here.
960 */
968 }
971 {
972 /* ROW() op ROW() is handled specially */
981 }
982 else
983 {
984 /* Ordinary scalar operator */
992 lexpr,
993 rexpr,
994 last_srf,
996 }
999 }
1003 {
1010 lexpr,
1011 rexpr,
1013 }
1017 {
1024 lexpr,
1025 rexpr,
1027 }
1031 {
1036 /*
1037 * If either input is an undecorated NULL literal, transform to a NullTest
1038 * on the other input. That's simpler to process than a full DistinctExpr,
1039 * and it avoids needing to require that the datatype have an = operator.
1040 */
1051 {
1052 /* ROW() op ROW() is handled specially */
1057 }
1058 else
1059 {
1060 /* Ordinary scalar operator */
1063 lexpr,
1064 rexpr,
1066 }
1068 /*
1069 * If it's NOT DISTINCT, we first build a DistinctExpr and then stick a
1070 * NOT on top.
1071 */
1078 }
1082 {
1089 lexpr,
1090 rexpr,
1094 /*
1095 * The comparison operator itself should yield boolean ...
1096 */
1100 /* translator: %s is name of a SQL construct, eg NULLIF */
1106 /* translator: %s is name of a SQL construct, eg NULLIF */
1110 /*
1111 * ... but the NullIfExpr will yield the first operand's type.
1112 */
1115 /*
1116 * We rely on NullIfExpr and OpExpr being the same struct
1117 */
1121 }
1125 {
1134 /*
1135 * If the operator is <>, combine with AND not OR.
1136 */
1139 else
1142 /*
1143 * We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only
1144 * possible if there is a suitable array type available. If not, we fall
1145 * back to a boolean condition tree with multiple copies of the lefthand
1146 * expression. Also, any IN-list items that contain Vars are handled as
1147 * separate boolean conditions, because that gives the planner more scope
1148 * for optimization on such clauses.
1149 *
1150 * First step: transform all the inputs, and detect whether any contain
1151 * Vars.
1152 */
1156 {
1162 else
1164 }
1166 /*
1167 * ScalarArrayOpExpr is only going to be useful if there's more than one
1168 * non-Var righthand item.
1169 */
1171 {
1173 Oid scalar_type;
1174 Oid array_type;
1176 /*
1177 * Try to select a common type for the array elements. Note that
1178 * since the LHS' type is first in the list, it will be preferred when
1179 * there is doubt (eg, when all the RHS items are unknown literals).
1180 *
1181 * Note: use list_concat here not lcons, to avoid damaging rnonvars.
1182 */
1186 /* We have to verify that the selected type actually works */
1191 /*
1192 * Do we have an array type to use? Aside from the case where there
1193 * isn't one, we don't risk using ScalarArrayOpExpr when the common
1194 * type is RECORD, because the RowExpr comparison logic below can cope
1195 * with some cases of non-identical row types.
1196 */
1199 else
1202 {
1203 /*
1204 * OK: coerce all the right-hand non-Var inputs to the common type
1205 * and build an ArrayExpr for them.
1206 */
1212 {
1216 scalar_type,
1219 }
1222 /* array_collid will be set by parse_collate.c */
1230 useOr,
1231 lexpr,
1235 /* Consider only the Vars (if any) in the loop below */
1237 }
1238 }
1240 /*
1241 * Must do it the hard way, ie, with a boolean expression tree.
1242 */
1244 {
1250 {
1251 /* ROW() op ROW() is handled specially */
1257 }
1258 else
1259 {
1260 /* Ordinary scalar operator */
1264 rexpr,
1267 }
1272 else
1276 }
1279 }
1283 {
1292 /* Deconstruct A_Expr into three subexprs */
1299 /*
1300 * Build the equivalent comparison expression. Make copies of
1301 * multiply-referenced subexpressions for safety. (XXX this is really
1302 * wrong since it results in multiple runtime evaluations of what may be
1303 * volatile expressions ...)
1304 *
1305 * Ideally we would not use hard-wired operators here but instead use
1306 * opclasses. However, mixed data types and other issues make this
1307 * difficult:
1308 * http://archives.postgresql.org/pgsql-hackers/2008-08/msg01142.php
1309 */
1311 {
1370 }
1373 }
1377 {
1378 /*
1379 * All we need to do is check that we're in the RETURNING list of a MERGE
1380 * command. If so, we just return the node as-is.
1381 */
1383 {
1395 }
1398 }
1402 {
1408 {
1422 }
1425 {
1431 }
1434 }
1438 {
1443 /* Transform the list of arguments ... */
1446 {
1449 }
1451 /*
1452 * When WITHIN GROUP is used, we treat its ORDER BY expressions as
1453 * additional arguments to the function, for purposes of function lookup
1454 * and argument type coercion. So, transform each such expression and add
1455 * them to the targs list. We don't explicitly mark where each argument
1456 * came from, but ParseFuncOrColumn can tell what's what by reference to
1457 * list_length(fn->agg_order).
1458 */
1460 {
1463 {
1467 EXPR_KIND_ORDER_BY));
1468 }
1469 }
1471 /* ... and hand off to ParseFuncOrColumn */
1474 targs,
1475 last_srf,
1476 fn,
1479 }
1483 {
1489 /* We should only see this in first-stage processing of UPDATE tlists */
1492 /* We only need to transform the source if this is the first column */
1494 {
1495 /*
1496 * For now, we only allow EXPR SubLinks and RowExprs as the source of
1497 * an UPDATE multiassignment. This is sufficient to cover interesting
1498 * cases; at worst, someone would have to write (SELECT * FROM expr)
1499 * to expand a composite-returning expression of another form.
1500 */
1503 {
1504 /* Relabel it as a MULTIEXPR_SUBLINK */
1507 /* And transform it */
1513 /* Check subquery returns required number of columns */
1520 /*
1521 * Build a resjunk tlist item containing the MULTIEXPR SubLink,
1522 * and add it to pstate->p_multiassign_exprs, whence it will later
1523 * get appended to the completed targetlist. We needn't worry
1524 * about selecting a resno for it; transformUpdateStmt will do
1525 * that.
1526 */
1529 tle);
1531 /*
1532 * Assign a unique-within-this-targetlist ID to the MULTIEXPR
1533 * SubLink. We can just use its position in the
1534 * p_multiassign_exprs list.
1535 */
1537 }
1539 {
1540 /* Transform the RowExpr, allowing SetToDefault items */
1545 /* Check it returns required number of columns */
1552 /*
1553 * Temporarily append it to p_multiassign_exprs, so we can get it
1554 * back when we come back here for additional columns.
1555 */
1558 tle);
1559 }
1560 else
1565 }
1566 else
1567 {
1568 /*
1569 * Second or later column in a multiassignment. Re-fetch the
1570 * transformed SubLink or RowExpr, which we assume is still the last
1571 * entry in p_multiassign_exprs.
1572 */
1575 }
1577 /*
1578 * Emit the appropriate output expression for the current column
1579 */
1581 {
1588 /* Build a Param representing the current subquery output column */
1601 }
1604 {
1609 /* Just extract and return the next element of the RowExpr */
1612 /*
1613 * If we're at the last column, delete the RowExpr from
1614 * p_multiassign_exprs; we don't need it anymore, and don't want it in
1615 * the finished UPDATE tlist. We assume this is still the last entry
1616 * in p_multiassign_exprs.
1617 */
1623 }
1627 }
1631 {
1640 Oid ptype;
1642 /* transform the test expression, if any */
1645 /* generate placeholder for test expression */
1647 {
1648 /*
1649 * If test expression is an untyped literal, force it to text. We have
1650 * to do something now because we won't be able to do this coercion on
1651 * the placeholder. This is not as flexible as what was done in 7.4
1652 * and before, but it's good enough to handle the sort of silly coding
1653 * commonly seen.
1654 */
1658 /*
1659 * Run collation assignment on the test expression so that we know
1660 * what collation to mark the placeholder with. In principle we could
1661 * leave it to parse_collate.c to do that later, but propagating the
1662 * result to the CaseTestExpr would be unnecessarily complicated.
1663 */
1670 }
1671 else
1676 /* transform the list of arguments */
1680 {
1687 {
1688 /* shorthand form was specified, so expand... */
1691 warg,
1693 }
1706 }
1710 /* transform the default clause */
1713 {
1719 }
1722 /*
1723 * Note: default result is considered the most significant type in
1724 * determining preferred type. This is how the code worked before, but it
1725 * seems a little bogus to me --- tgl
1726 */
1732 /* casecollid will be set by parse_collate.c */
1734 /* Convert default result clause, if necessary */
1738 ptype,
1741 /* Convert when-clause results, if necessary */
1743 {
1749 ptype,
1751 }
1753 /* if any subexpression contained a SRF, complain */
1757 /* translator: %s is name of a SQL construct, eg GROUP BY */
1767 }
1771 {
1776 /*
1777 * Check to see if the sublink is in an invalid place within the query. We
1778 * allow sublinks everywhere in SELECT/INSERT/UPDATE/DELETE/MERGE, but
1779 * generally not in utility statements.
1780 */
1783 {
1788 /* Accept sublink here; caller must throw error if wanted */
1818 /* okay */
1862 /*
1863 * There is intentionally no default: case here, so that the
1864 * compiler will warn if we add a new ParseExprKind without
1865 * extending this switch. If we do see an unrecognized value at
1866 * runtime, the behavior will be the same as for EXPR_KIND_OTHER,
1867 * which is sane anyway.
1868 */
1869 }
1878 /*
1879 * OK, let's transform the sub-SELECT.
1880 */
1883 /*
1884 * Check that we got a SELECT. Anything else should be impossible given
1885 * restrictions of the grammar, but check anyway.
1886 */
1894 {
1895 /*
1896 * EXISTS needs no test expression or combining operator. These fields
1897 * should be null already, but make sure.
1898 */
1901 }
1904 {
1905 /*
1906 * Make sure the subselect delivers a single column (ignoring resjunk
1907 * targets).
1908 */
1915 /*
1916 * EXPR and ARRAY need no test expression or combining operator. These
1917 * fields should be null already, but make sure.
1918 */
1921 }
1923 {
1924 /* Same as EXPR case, except no restriction on number of columns */
1927 }
1928 else
1929 {
1930 /* ALL, ANY, or ROWCOMPARE: generate row-comparing expression */
1936 /*
1937 * If the source was "x IN (select)", convert to "x = ANY (select)".
1938 */
1942 /*
1943 * Transform lefthand expression, and convert to a list
1944 */
1948 else
1951 /*
1952 * Build a list of PARAM_SUBLINK nodes representing the output columns
1953 * of the subquery.
1954 */
1957 {
1973 }
1975 /*
1976 * We could rely on make_row_comparison_op to complain if the list
1977 * lengths differ, but we prefer to generate a more specific error
1978 * message.
1979 */
1991 /*
1992 * Identify the combining operator(s) and generate a suitable
1993 * row-comparison expression.
1994 */
1997 left_list,
1998 right_list,
2000 }
2003 }
2005 /*
2006 * transformArrayExpr
2007 *
2008 * If the caller specifies the target type, the resulting array will
2009 * be of exactly that type. Otherwise we try to infer a common type
2010 * for the elements using select_common_type().
2011 */
2015 {
2020 Oid coerce_type;
2023 /*
2024 * Transform the element expressions
2025 *
2026 * Assume that the array is one-dimensional unless we find an array-type
2027 * element expression.
2028 */
2031 {
2035 /*
2036 * If an element is itself an A_ArrayExpr, recurse directly so that we
2037 * can pass down any target type we were given.
2038 */
2040 {
2043 array_type,
2044 element_type,
2045 typmod);
2046 /* we certainly have an array here */
2049 }
2050 else
2051 {
2054 /*
2055 * Check for sub-array expressions, if we haven't already found
2056 * one.
2057 */
2060 }
2063 }
2065 /*
2066 * Select a target type for the elements.
2067 *
2068 * If we haven't been given a target array type, we must try to deduce a
2069 * common type based on the types of the individual elements present.
2070 */
2072 {
2073 /* Caller must ensure array_type matches element_type */
2077 }
2078 else
2079 {
2080 /* Can't handle an empty array without a target type */
2089 /* Select a common type for the elements */
2093 {
2102 }
2103 else
2104 {
2113 }
2115 }
2117 /*
2118 * Coerce elements to target type
2119 *
2120 * If the array has been explicitly cast, then the elements are in turn
2121 * explicitly coerced.
2122 *
2123 * If the array's type was merely derived from the common type of its
2124 * elements, then the elements are implicitly coerced to the common type.
2125 * This is consistent with other uses of select_common_type().
2126 */
2128 {
2133 {
2136 coerce_type,
2137 typmod,
2138 COERCION_EXPLICIT,
2139 COERCE_EXPLICIT_CAST,
2148 }
2149 else
2151 coerce_type,
2154 }
2157 /* array_collid will be set by parse_collate.c */
2163 }
2167 {
2174 /* Transform the field expressions */
2178 /* Disallow more columns than will fit in a tuple */
2183 MaxTupleAttributeNumber),
2186 /* Barring later casting, we consider the type RECORD */
2190 /* ROW() has anonymous columns, so invent some field names */
2193 {
2196 }
2201 }
2205 {
2213 {
2219 }
2222 /* coalescecollid will be set by parse_collate.c */
2224 /* Convert arguments if necessary */
2226 {
2234 }
2236 /* if any subexpression contained a SRF, complain */
2240 /* translator: %s is name of a SQL construct, eg GROUP BY */
2250 }
2254 {
2263 {
2269 }
2272 /* minmaxcollid and inputcollid will be set by parse_collate.c */
2274 /* Convert arguments if necessary */
2276 {
2282 funcname);
2284 }
2289 }
2293 {
2294 /*
2295 * All we need to do is insert the correct result type and (where needed)
2296 * validate the typmod, so we just modify the node in-place.
2297 */
2299 {
2339 }
2342 }
2346 {
2355 else
2362 /*
2363 * gram.y built the named args as a list of ResTarget. Transform each,
2364 * and break the names out as a separate list.
2365 */
2370 {
2382 else
2383 {
2391 }
2393 /* reject duplicate argnames in XMLELEMENT only */
2395 {
2399 {
2404 argname),
2406 }
2407 }
2411 }
2413 /* The other arguments are of varying types depending on the function */
2417 {
2423 {
2429 /* no coercion necessary */
2439 else
2453 else
2458 /* not handled here */
2465 }
2467 i++;
2468 }
2471 }
2475 {
2478 Oid targetType;
2479 int32 targetTypmod;
2485 XMLOID,
2493 /* We actually only need these to be able to parse back the expression. */
2497 /*
2498 * The actual target type is determined this way. SQL allows char and
2499 * varchar as target types. We allow anything that can be cast implicitly
2500 * from text. This way, user-defined text-like data types automatically
2501 * fit in.
2502 */
2505 COERCION_IMPLICIT,
2506 COERCE_IMPLICIT_CAST,
2515 }
2519 {
2523 {
2546 }
2552 clausename);
2555 }
2559 {
2560 /* CURRENT OF can only appear at top level of UPDATE/DELETE */
2564 /*
2565 * Check to see if the cursor name matches a parameter of type REFCURSOR.
2566 * If so, replace the raw name reference with a parameter reference. (This
2567 * is a hack for the convenience of plpgsql.)
2568 */
2570 {
2574 /* Build an unqualified ColumnRef with the given name */
2578 /* See if there is a translation available from a parser hook */
2584 /*
2585 * XXX Should we throw an error if we get a translation that isn't a
2586 * refcursor Param? For now it seems best to silently ignore false
2587 * matches.
2588 */
2590 {
2595 {
2596 /* Matches, so convert CURRENT OF to a param reference */
2599 }
2600 }
2601 }
2604 }
2606 /*
2607 * Construct a whole-row reference to represent the notation "relation.*".
2608 */
2612 {
2613 /*
2614 * Build the appropriate referencing node. Normally this can be a
2615 * whole-row Var, but if the nsitem is a JOIN USING alias then it contains
2616 * only a subset of the columns of the underlying join RTE, so that will
2617 * not work. Instead we immediately expand the reference into a RowExpr.
2618 * Since the JOIN USING's common columns are fully determined at this
2619 * point, there seems no harm in expanding it now rather than during
2620 * planning.
2621 *
2622 * Note that if the nsitem is an OLD/NEW alias for the target RTE (as can
2623 * appear in a RETURNING list), its alias won't match the target RTE's
2624 * alias, but we still want to make a whole-row Var here rather than a
2625 * RowExpr, for consistency with direct references to the target RTE, and
2626 * so that any dropped columns are handled correctly. Thus we also check
2627 * p_returning_type here.
2628 *
2629 * Note that if the RTE is a function returning scalar, we create just a
2630 * plain reference to the function value, not a composite containing a
2631 * single column. This is pretty inconsistent at first sight, but it's
2632 * what we've done historically. One argument for it is that "rel" and
2633 * "rel.*" mean the same thing for composite relations, so why not for
2634 * scalar functions...
2635 */
2638 {
2644 /* mark Var for RETURNING OLD/NEW, as necessary */
2647 /* location is not filled in by makeWholeRowVar */
2650 /* mark Var if it's nulled by any outer joins */
2653 /* mark relation as requiring whole-row SELECT access */
2657 }
2658 else
2659 {
2663 /*
2664 * We want only as many columns as are listed in p_names->colnames,
2665 * and we should use those names not whatever possibly-aliased names
2666 * are in the RTE. We needn't worry about marking the RTE for SELECT
2667 * access, as the common columns are surely so marked already.
2668 */
2679 /* XXX we ought to mark the row as possibly nullable */
2682 }
2683 }
2685 /*
2686 * Handle an explicit CAST construct.
2687 *
2688 * Transform the argument, look up the type name, and apply any necessary
2689 * coercion function(s).
2690 */
2693 {
2697 Oid inputType;
2698 Oid targetType;
2699 int32 targetTypmod;
2702 /* Look up the type name first */
2705 /*
2706 * If the subject of the typecast is an ARRAY[] construct and the target
2707 * type is an array type, we invoke transformArrayExpr() directly so that
2708 * we can pass down the type information. This avoids some cases where
2709 * transformArrayExpr() might not infer the correct type. Otherwise, just
2710 * transform the argument normally.
2711 */
2713 {
2714 Oid targetBaseType;
2715 int32 targetBaseTypmod;
2716 Oid elementType;
2718 /*
2719 * If target is a domain over array, work with the base array type
2720 * here. Below, we'll cast the array type to the domain. In the
2721 * usual case that the target is not a domain, the remaining steps
2722 * will be a no-op.
2723 */
2728 {
2731 targetBaseType,
2732 elementType,
2733 targetBaseTypmod);
2734 }
2735 else
2737 }
2738 else
2745 /*
2746 * Location of the coercion is preferentially the location of the :: or
2747 * CAST symbol, but if there is none then use the location of the type
2748 * name (this can happen in TypeName 'string' syntax, for instance).
2749 */
2756 COERCION_EXPLICIT,
2757 COERCE_EXPLICIT_CAST,
2758 location);
2768 }
2770 /*
2771 * Handle an explicit COLLATE clause.
2772 *
2773 * Transform the argument, and look up the collation name.
2774 */
2777 {
2779 Oid argtype;
2786 /*
2787 * The unknown type is not collatable, but coerce_type() takes care of it
2788 * separately, so we'll let it go here.
2789 */
2801 }
2803 /*
2804 * Transform a "row compare-op row" construct
2805 *
2806 * The inputs are lists of already-transformed expressions.
2807 * As with coerce_type, pstate may be NULL if no special unknown-Param
2808 * processing is wanted.
2809 *
2810 * The output may be a single OpExpr, an AND or OR combination of OpExprs,
2811 * or a RowCompareExpr. In all cases it is guaranteed to return boolean.
2812 * The AND, OR, and RowCompareExpr cases further imply things about the
2813 * behavior of the operators (ie, they behave as =, <>, or < <= > >=).
2814 */
2818 {
2820 CompareType cmptype;
2838 /*
2839 * We can't compare zero-length rows because there is no principled basis
2840 * for figuring out what the operator is.
2841 */
2848 /*
2849 * Identify all the pairwise operators, using make_op so that behavior is
2850 * the same as in the simple scalar case.
2851 */
2854 {
2862 /*
2863 * We don't use coerce_to_boolean here because we insist on the
2864 * operator yielding boolean directly, not via coercion. If it
2865 * doesn't yield bool it won't be in any index opfamilies...
2866 */
2880 }
2882 /*
2883 * If rows are length 1, just return the single operator. In this case we
2884 * don't insist on identifying btree semantics for the operator (but we
2885 * still require it to return boolean).
2886 */
2890 /*
2891 * Now we must determine which row comparison semantics (= <> < <= > >=)
2892 * apply to this set of operators. We look for btree opfamilies
2893 * containing the operators, and see which interpretations (strategy
2894 * numbers) exist for each operator.
2895 */
2900 {
2907 /*
2908 * convert strategy numbers into a Bitmapset to make the intersection
2909 * calculation easy.
2910 */
2913 {
2917 }
2920 else
2922 i++;
2923 }
2925 /*
2926 * If there are multiple common interpretations, we may use any one of
2927 * them ... this coding arbitrarily picks the lowest btree strategy
2928 * number.
2929 */
2932 {
2933 /* No common interpretation, so fail */
2940 }
2943 /*
2944 * For = and <> cases, we just combine the pairwise operators with AND or
2945 * OR respectively.
2946 */
2952 /*
2953 * Otherwise we need to choose exactly which opfamily to associate with
2954 * each operator.
2955 */
2958 {
2963 {
2967 {
2970 }
2971 }
2981 }
2983 /*
2984 * Now deconstruct the OpExprs and create a RowCompareExpr.
2985 *
2986 * Note: can't just reuse the passed largs/rargs lists, because of
2987 * possibility that make_op inserted coercion operations.
2988 */
2993 {
2999 }
3010 }
3012 /*
3013 * Transform a "row IS DISTINCT FROM row" construct
3014 *
3015 * The input RowExprs are already transformed
3016 */
3021 {
3035 {
3043 else
3046 location);
3047 }
3050 {
3051 /* zero-length rows? Generate constant FALSE */
3053 }
3056 }
3058 /*
3059 * make the node for an IS DISTINCT FROM operator
3060 */
3064 {
3072 /* translator: %s is name of a SQL construct, eg NULLIF */
3079 /* translator: %s is name of a SQL construct, eg NULLIF */
3083 /*
3084 * We rely on DistinctExpr and OpExpr being same struct
3085 */
3089 }
3091 /*
3092 * Produce a NullTest node from an IS [NOT] DISTINCT FROM NULL construct
3093 *
3094 * "arg" is the untransformed other argument
3095 */
3098 {
3102 /* the argument can be any type, so don't coerce it */
3105 else
3107 /* argisrow = false is correct whether or not arg is composite */
3111 }
3113 /*
3114 * Produce a string identifying an expression by kind.
3115 *
3116 * Note: when practical, use a simple SQL keyword for the result. If that
3117 * doesn't work well, check call sites to see whether custom error message
3118 * strings are required.
3119 */
3122 {
3124 {
3211 /*
3212 * There is intentionally no default: case here, so that the
3213 * compiler will warn if we add a new ParseExprKind without
3214 * extending this switch. If we do see an unrecognized value at
3215 * runtime, we'll fall through to the "unrecognized" return.
3216 */
3217 }
3219 }
3221 /*
3222 * Make string Const node from JSON encoding name.
3223 *
3224 * UTF8 is default encoding.
3225 */
3228 {
3229 JsonEncoding encoding;
3237 else
3241 {
3254 }
3260 }
3262 /*
3263 * Make bytea => text conversion using specified JSON format encoding.
3264 */
3267 {
3272 COERCE_EXPLICIT_CALL);
3277 }
3279 /*
3280 * Transform JSON value expression using specified input JSON format or
3281 * default format otherwise, coercing to the targettype if needed.
3282 *
3283 * Returned expression is either ve->raw_expr coerced to text (if needed) or
3284 * a JsonValueExpr with formatted_expr set to the coerced copy of raw_expr
3285 * if the specified format and the targettype requires it.
3286 */
3291 {
3294 JsonFormatType format;
3295 Oid exprtype;
3310 {
3319 else
3321 }
3323 {
3324 /*
3325 * Special treatment for PASSING arguments.
3326 *
3327 * Pass types supported by GetJsonPathVar() / JsonItemFromDatum()
3328 * directly without converting to json[b].
3329 */
3331 {
3351 /* else convert argument to json[b] type */
3353 }
3356 }
3359 else
3364 {
3368 /*
3369 * PASSING args are handled appropriately by GetJsonPathVar() /
3370 * JsonItemFromDatum().
3371 */
3383 /* Convert encoded JSON text from bytea. */
3385 {
3388 }
3393 /* Try to coerce to the target type. */
3396 COERCION_EXPLICIT,
3397 COERCE_EXPLICIT_CAST,
3398 location);
3401 {
3402 /* If coercion failed, use to_json()/to_jsonb() functions. */
3404 Oid fnoid;
3406 /*
3407 * Though only allow a cast when the target type is specified by
3408 * the caller.
3409 */
3425 }
3429 else
3430 {
3436 }
3437 }
3439 /* If returning a JsonValueExpr, formatted_expr must have been set. */
3444 }
3446 /*
3447 * Checks specified output format for its applicability to the target type.
3448 */
3449 static void
3452 {
3458 {
3469 }
3472 {
3489 }
3490 }
3492 /*
3493 * Transform JSON output clause.
3494 *
3495 * Assigns target type oid and modifier.
3496 * Assigns default format or checks specified format for its applicability to
3497 * the target type.
3498 */
3502 {
3505 /* if output clause is not specified, make default clause value */
3507 {
3515 }
3532 /* assign JSONB format when returning jsonb, or JSON format otherwise */
3535 else
3539 }
3541 /*
3542 * Transform JSON output clause of JSON constructor functions.
3543 *
3544 * Derive RETURNING type, if not specified, from argument types.
3545 */
3549 {
3553 {
3558 {
3566 }
3569 {
3572 }
3573 else
3574 {
3575 /* XXX TEXT is default by the standard, but we return JSON */
3578 }
3581 }
3584 }
3586 /*
3587 * Coerce json[b]-valued function expression to the output type.
3588 */
3592 {
3597 /* if output type is not specified or equals to function type, return */
3606 /* special case for RETURNING bytea FORMAT json */
3609 {
3610 /* encode json text into bytea using pg_convert_to() */
3617 COERCE_EXPLICIT_CALL);
3622 }
3624 /*
3625 * For other cases, try to coerce expression to the output type using
3626 * assignment-level casts, erroring out if none available. This basically
3627 * allows coercing the jsonb value to any string type (typcategory = 'S').
3628 *
3629 * Requesting assignment-level here means that typmod / length coercion
3630 * assumes implicit coercion which is the behavior we want; see
3631 * build_coercion_expression().
3632 */
3635 COERCION_ASSIGNMENT,
3636 COERCE_IMPLICIT_CAST,
3637 location);
3648 }
3650 /*
3651 * Make a JsonConstructorExpr node.
3652 */
3657 {
3670 /*
3671 * Coerce to the RETURNING type and format, if needed. We abuse
3672 * CaseTestExpr here as placeholder to pass the result of either
3673 * evaluating 'fexpr' or whatever is produced by ExecEvalJsonConstructor()
3674 * that is of type JSON or JSONB to the coercion function.
3675 */
3677 {
3685 }
3686 else
3687 {
3696 }
3704 }
3706 /*
3707 * Transform JSON_OBJECT() constructor.
3708 *
3709 * JSON_OBJECT() is transformed into a JsonConstructorExpr node of type
3710 * JSCTOR_JSON_OBJECT. The result is coerced to the target type given
3711 * by ctor->output.
3712 */
3715 {
3719 /* transform key-value pairs, if any */
3721 {
3724 /* transform and append key-value arguments */
3726 {
3731 JS_FORMAT_DEFAULT,
3736 }
3737 }
3744 }
3746 /*
3747 * Transform JSON_ARRAY(query [FORMAT] [RETURNING] [ON NULL]) into
3748 * (SELECT JSON_ARRAYAGG(a [FORMAT] [RETURNING] [ON NULL]) FROM (query) q(a))
3749 */
3753 {
3764 /* Transform query only for counting target list entries. */
3781 /*
3782 * No formatting necessary, so set formatted_expr to be the same as
3783 * raw_expr.
3784 */
3816 }
3818 /*
3819 * Common code for JSON_OBJECTAGG and JSON_ARRAYAGG transformation.
3820 */
3825 JsonConstructorType ctor_type,
3827 {
3836 {
3837 /* window function */
3842 /* wincollid and inputcollid will be set by parse_collate.c */
3846 /* winref will be set by transformWindowFuncCall */
3851 /*
3852 * ordered aggs not allowed in windows yet
3853 */
3860 /* parse_agg.c does additional window-func-specific processing */
3864 }
3865 else
3866 {
3872 /* aggcollid and inputcollid will be set by parse_collate.c */
3873 /* aggtranstype will be set by planner */
3874 /* aggargtypes will be set by transformAggregateCall */
3875 /* aggdirectargs and args will be set by transformAggregateCall */
3876 /* aggorder and aggdistinct will be set by transformAggregateCall */
3882 /* agglevelsup will be set by transformAggregateCall */
3891 }
3896 }
3898 /*
3899 * Transform JSON_OBJECTAGG() aggregate function.
3900 *
3901 * JSON_OBJECTAGG() is transformed into a JsonConstructorExpr node of type
3902 * JSCTOR_JSON_OBJECTAGG, which at runtime becomes a
3903 * json[b]_object_agg[_unique][_strict](agg->arg->key, agg->arg->value) call
3904 * depending on the output JSON format. The result is coerced to the target
3905 * type given by agg->constructor->output.
3906 */
3909 {
3914 Oid aggfnoid;
3915 Oid aggtype;
3920 JS_FORMAT_DEFAULT,
3925 args);
3928 {
3932 else
3936 else
3940 }
3941 else
3942 {
3946 else
3950 else
3954 }
3958 JSCTOR_JSON_OBJECTAGG,
3960 }
3962 /*
3963 * Transform JSON_ARRAYAGG() aggregate function.
3964 *
3965 * JSON_ARRAYAGG() is transformed into a JsonConstructorExpr node of type
3966 * JSCTOR_JSON_ARRAYAGG, which at runtime becomes a
3967 * json[b]_object_agg[_unique][_strict](agg->arg) call depending on the output
3968 * JSON format. The result is coerced to the target type given by
3969 * agg->constructor->output.
3970 */
3973 {
3976 Oid aggfnoid;
3977 Oid aggtype;
3986 {
3989 }
3990 else
3991 {
3994 }
3998 JSCTOR_JSON_ARRAYAGG,
4000 }
4002 /*
4003 * Transform JSON_ARRAY() constructor.
4004 *
4005 * JSON_ARRAY() is transformed into a JsonConstructorExpr node of type
4006 * JSCTOR_JSON_ARRAY. The result is coerced to the target type given
4007 * by ctor->output.
4008 */
4011 {
4015 /* transform element expressions, if any */
4017 {
4020 /* transform and append element arguments */
4022 {
4029 }
4030 }
4037 }
4042 {
4048 /* prepare input document */
4050 {
4059 }
4060 else
4061 {
4068 {
4071 COERCION_IMPLICIT,
4074 }
4081 }
4084 }
4086 /*
4087 * Transform IS JSON predicate.
4088 */
4091 {
4092 Oid exprtype;
4096 /* make resulting expression */
4103 /* This intentionally(?) drops the format clause. */
4106 }
4108 /*
4109 * Transform the RETURNING clause of a JSON_*() expression if there is one and
4110 * create one if not.
4111 */
4114 {
4118 {
4130 }
4131 else
4132 {
4133 /* Output type is JSON by default. */
4141 }
4144 }
4146 /*
4147 * Transform a JSON() expression.
4148 *
4149 * JSON() is transformed into a JsonConstructorExpr of type JSCTOR_JSON_PARSE,
4150 * which validates the input expression value as JSON.
4151 */
4154 {
4162 {
4163 /*
4164 * Coerce string argument to text and then to json[b] in the executor
4165 * node with key uniqueness check.
4166 */
4168 Oid arg_type;
4178 }
4179 else
4180 {
4181 /*
4182 * Coerce argument to target type using CAST for compatibility with PG
4183 * function-like CASTs.
4184 */
4187 }
4192 }
4194 /*
4195 * Transform a JSON_SCALAR() expression.
4196 *
4197 * JSON_SCALAR() is transformed into a JsonConstructorExpr of type
4198 * JSCTOR_JSON_SCALAR, which converts the input SQL scalar value into
4199 * a json[b] value.
4200 */
4203 {
4215 }
4217 /*
4218 * Transform a JSON_SERIALIZE() expression.
4219 *
4220 * JSON_SERIALIZE() is transformed into a JsonConstructorExpr of type
4221 * JSCTOR_JSON_SERIALIZE which converts the input JSON value into a character
4222 * or bytea string.
4223 */
4226 {
4230 JS_FORMAT_JSON,
4234 {
4238 {
4251 }
4252 }
4253 else
4254 {
4255 /* RETURNING TEXT FORMAT JSON is by default */
4260 }
4264 }
4266 /*
4267 * Transform JSON_VALUE, JSON_QUERY, JSON_EXISTS, JSON_TABLE functions into
4268 * a JsonExpr node.
4269 */
4272 {
4276 JsonFormatType default_format;
4279 {
4300 }
4302 /*
4303 * Even though the syntax allows it, FORMAT JSON specification in
4304 * RETURNING is meaningless except for JSON_QUERY(). Flag if not
4305 * JSON_QUERY().
4306 */
4308 {
4316 func_name),
4318 }
4320 /* OMIT QUOTES is meaningless when strings are wrapped. */
4322 {
4337 {
4341 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4343 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY),
4344 second %s is a SQL/JSON function name (e.g. JSON_QUERY) */
4345 errdetail("Only ERROR, NULL, EMPTY ARRAY, EMPTY OBJECT, or DEFAULT expression is allowed in %s for %s.",
4348 else
4351 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4354 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4355 errdetail("Only ERROR, NULL, EMPTY ARRAY, EMPTY OBJECT, or DEFAULT expression is allowed in %s for formatted columns.",
4358 }
4366 {
4370 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4372 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY),
4373 second %s is a SQL/JSON function name (e.g. JSON_QUERY) */
4374 errdetail("Only ERROR, NULL, EMPTY ARRAY, EMPTY OBJECT, or DEFAULT expression is allowed in %s for %s.",
4377 else
4380 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4383 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4384 errdetail("Only ERROR, NULL, EMPTY ARRAY, EMPTY OBJECT, or DEFAULT expression is allowed in %s for formatted columns.",
4387 }
4388 }
4390 /* Check that ON ERROR/EMPTY behavior values are valid for the function. */
4397 {
4401 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4406 else
4409 /*- translator: first %s is name a SQL/JSON clause (eg. ON EMPTY) */
4412 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4416 }
4418 {
4423 {
4427 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4429 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY),
4430 second %s is a SQL/JSON function name (e.g. JSON_QUERY) */
4434 else
4437 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4440 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4444 }
4449 {
4453 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4455 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY),
4456 second %s is a SQL/JSON function name (e.g. JSON_QUERY) */
4460 else
4463 /*- translator: first %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4466 /*- translator: %s is name of a SQL/JSON clause (eg. ON EMPTY) */
4470 }
4471 }
4478 /*
4479 * jsonpath machinery can only handle jsonb documents, so coerce the input
4480 * if not already of jsonb type.
4481 */
4484 default_format,
4485 JSONBOID,
4502 /* Transform and coerce the PASSING arguments to jsonb. */
4504 JS_FORMAT_JSONB,
4509 /* Transform the JsonOutput into JsonReturning. */
4513 {
4515 /* JSON_EXISTS returns boolean by default. */
4517 {
4520 }
4522 /* JSON_TABLE() COLUMNS can specify a non-boolean type. */
4527 JSON_BEHAVIOR_FALSE,
4532 /* JSON_QUERY returns jsonb by default. */
4534 {
4539 }
4541 /*
4542 * Keep quotes on scalar strings by default, omitting them only if
4543 * OMIT QUOTES is specified.
4544 */
4548 /*
4549 * Set up to coerce the result value of JsonPathValue() to the
4550 * RETURNING type (default or user-specified), if needed. Also if
4551 * OMIT QUOTES is specified.
4552 */
4556 /* Assume NULL ON EMPTY when ON EMPTY is not specified. */
4558 JSON_BEHAVIOR_NULL,
4560 /* Assume NULL ON ERROR when ON ERROR is not specified. */
4562 JSON_BEHAVIOR_NULL,
4567 /* JSON_VALUE returns text by default. */
4569 {
4572 }
4574 /*
4575 * Override whatever transformJsonOutput() set these to, which
4576 * assumes that output type to be jsonb.
4577 */
4581 /* Always omit quotes from scalar strings. */
4584 /*
4585 * Set up to coerce the result value of JsonPathValue() to the
4586 * RETURNING type (default or user-specified), if needed.
4587 */
4589 {
4593 else
4595 }
4597 /* Assume NULL ON EMPTY when ON EMPTY is not specified. */
4599 JSON_BEHAVIOR_NULL,
4601 /* Assume NULL ON ERROR when ON ERROR is not specified. */
4603 JSON_BEHAVIOR_NULL,
4609 {
4612 }
4614 /*
4615 * Assume EMPTY ARRAY ON ERROR when ON ERROR is not specified.
4616 *
4617 * ON EMPTY cannot be specified at the top level but it can be for
4618 * the individual columns.
4619 */
4621 JSON_BEHAVIOR_EMPTY_ARRAY,
4628 }
4631 }
4633 /*
4634 * Transform a SQL/JSON PASSING clause.
4635 */
4636 static void
4640 {
4647 {
4655 }
4656 }
4658 /*
4659 * Recursively checks if the given expression, or its sub-node in some cases,
4660 * is valid for using as an ON ERROR / ON EMPTY DEFAULT expression.
4661 */
4662 static bool
4664 {
4669 {
4670 /* Acceptable expression nodes */
4676 /* Acceptable iff arg of the following nodes is one of the above */
4684 context);
4687 }
4690 }
4692 /*
4693 * Transform a JSON BEHAVIOR clause.
4694 */
4697 JsonBehaviorType default_behavior,
4699 {
4706 {
4710 {
4715 errmsg("can only specify a constant, non-aggregate function, or operator expression for DEFAULT"),
4727 }
4728 }
4733 /*
4734 * Try to coerce the expression if needed.
4735 *
4736 * Use runtime coercion using json_populate_type() if the expression is
4737 * NULL, jsonb-valued, or boolean-valued (unless the target type is
4738 * integer or domain over integer, in which case use the
4739 * boolean-to-integer cast function).
4740 *
4741 * For other non-NULL expressions, try to find a cast and error out if one
4742 * is not found.
4743 */
4745 {
4752 {
4755 /*
4756 * json_populate_type() expects to be passed a jsonb value, so gin
4757 * up a Const containing the appropriate boolean value represented
4758 * as jsonb, discarding the original Const containing a plain
4759 * boolean.
4760 */
4762 {
4769 }
4770 }
4771 else
4772 {
4776 /*
4777 * Use an assignment cast if coercing to a string type so that
4778 * build_coercion_expression() assumes implicit coercion when
4779 * coercing the typmod, so that inputs exceeding length cause an
4780 * error instead of silent truncation.
4781 */
4782 coerced_expr =
4787 COERCION_ASSIGNMENT :
4788 COERCION_EXPLICIT,
4789 COERCE_EXPLICIT_CAST,
4793 {
4794 /*
4795 * Provide a HINT if the expression comes from a DEFAULT
4796 * clause.
4797 */
4807 else
4814 }
4817 }
4818 }
4822 else
4828 }
4830 /*
4831 * Returns a Const node holding the value for the given non-ERROR
4832 * JsonBehaviorType.
4833 */
4836 {
4845 {
4878 /* These two behavior types are handled by the caller. */
4887 }
4893 }