| blob | df779137c9d6a74284b307aba7c0dc72b39ba23d |
1 /*-------------------------------------------------------------------------
2 *
3 * nodeFuncs.c
4 * Various general-purpose manipulations of Node trees
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/nodes/nodeFuncs.c
12 *
13 *-------------------------------------------------------------------------
14 */
30 planstate_tree_walker_callback walker,
33 planstate_tree_walker_callback walker,
37 /*
38 * exprType -
39 * returns the Oid of the type of the expression's result.
40 */
41 Oid
43 {
44 Oid type;
50 {
97 {
102 {
103 /* get the type of the subselect's first target column */
113 {
120 }
121 }
123 {
124 /* MULTIEXPR is always considered to return RECORD */
126 }
127 else
128 {
129 /* for all other sublink types, result is boolean */
131 }
132 }
135 {
140 {
141 /* get the type of the subselect's first target column */
144 {
151 }
152 }
154 {
155 /* MULTIEXPR is always considered to return RECORD */
157 }
158 else
159 {
160 /* for all other subplan types, result is boolean */
162 }
163 }
166 {
169 /* subplans should all return the same thing */
171 }
223 else
227 {
231 }
240 {
245 }
247 {
252 }
275 {
279 }
288 }
290 }
292 /*
293 * exprTypmod -
294 * returns the type-specific modifier of the expression's result type,
295 * if it can be determined. In many cases, it can't and we return -1.
296 */
297 int32
299 {
304 {
314 {
315 int32 coercedTypmod;
317 /* Be smart about length-coercion functions... */
320 }
325 {
326 /*
327 * Result is either first argument or NULL, so we can report
328 * first argument's typmod if known.
329 */
333 }
336 {
341 {
342 /* get the typmod of the subselect's first target column */
351 /* note we don't need to care if it's an array */
352 }
353 /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
354 }
357 {
362 {
363 /* get the typmod of the subselect's first target column */
364 /* note we don't need to care if it's an array */
366 }
367 /* otherwise, result is RECORD or BOOLEAN, typmod is -1 */
368 }
371 {
374 /* subplans should all return the same thing */
376 }
387 {
388 /*
389 * If all the alternatives agree on type/typmod, return that
390 * typmod, else use -1
391 */
394 int32 typmod;
405 {
412 }
414 }
419 {
420 /*
421 * If all the elements agree on type/typmod, return that
422 * typmod, else use -1
423 */
425 Oid commontype;
426 int32 typmod;
436 else
439 {
446 }
448 }
451 {
452 /*
453 * If all the alternatives agree on type/typmod, return that
454 * typmod, else use -1
455 */
458 int32 typmod;
467 {
474 }
476 }
479 {
480 /*
481 * If all the alternatives agree on type/typmod, return that
482 * typmod, else use -1
483 */
486 int32 typmod;
495 {
502 }
504 }
513 {
517 }
520 {
524 }
536 }
538 }
540 /*
541 * exprIsLengthCoercion
542 * Detect whether an expression tree is an application of a datatype's
543 * typmod-coercion function. Optionally extract the result's typmod.
544 *
545 * If coercedTypmod is not NULL, the typmod is stored there if the expression
546 * is a length-coercion function, else -1 is stored there.
547 *
548 * Note that a combined type-and-length coercion will be treated as a
549 * length coercion by this routine.
550 */
551 bool
553 {
557 /*
558 * Scalar-type length coercions are FuncExprs, array-type length coercions
559 * are ArrayCoerceExprs
560 */
562 {
567 /*
568 * If it didn't come from a coercion context, reject.
569 */
574 /*
575 * If it's not a two-argument or three-argument function with the
576 * second argument being an int4 constant, it can't have been created
577 * from a length coercion (it must be a type coercion, instead).
578 */
589 /*
590 * OK, it is indeed a length-coercion function.
591 */
596 }
599 {
602 /* It's not a length coercion unless there's a nondefault typmod */
606 /*
607 * OK, it is indeed a length-coercion expression.
608 */
613 }
616 }
618 /*
619 * applyRelabelType
620 * Add a RelabelType node if needed to make the expression expose
621 * the specified type, typmod, and collation.
622 *
623 * This is primarily intended to be used during planning. Therefore, it must
624 * maintain the post-eval_const_expressions invariants that there are not
625 * adjacent RelabelTypes, and that the tree is fully const-folded (hence,
626 * we mustn't return a RelabelType atop a Const). If we do find a Const,
627 * we'll modify it in-place if "overwrite_ok" is true; that should only be
628 * passed as true if caller knows the Const is newly generated.
629 */
630 Node *
633 {
634 /*
635 * If we find stacked RelabelTypes (eg, from foo::int::oid) we can discard
636 * all but the top one, and must do so to ensure that semantically
637 * equivalent expressions are equal().
638 */
643 {
644 /* Modify the Const directly to preserve const-flatness. */
652 /* We keep the Const's original location. */
654 }
658 {
659 /* Sometimes we find a nest of relabels that net out to nothing. */
661 }
662 else
663 {
664 /* Nope, gotta have a RelabelType. */
674 }
675 }
677 /*
678 * relabel_to_typmod
679 * Add a RelabelType node that changes just the typmod of the expression.
680 *
681 * Convenience function for a common usage of applyRelabelType.
682 */
683 Node *
685 {
688 }
690 /*
691 * strip_implicit_coercions: remove implicit coercions at top level of tree
692 *
693 * This doesn't modify or copy the input expression tree, just return a
694 * pointer to a suitable place within it.
695 *
696 * Note: there isn't any useful thing we can do with a RowExpr here, so
697 * just return it unchanged, even if it's marked as an implicit coercion.
698 */
699 Node *
701 {
705 {
710 }
712 {
717 }
719 {
724 }
726 {
731 }
733 {
738 }
740 {
745 }
747 }
749 /*
750 * expression_returns_set
751 * Test whether an expression returns a set result.
752 *
753 * Because we use expression_tree_walker(), this can also be applied to
754 * whole targetlists; it'll produce true if any one of the tlist items
755 * returns a set.
756 */
757 bool
759 {
761 }
763 static bool
765 {
769 {
774 /* else fall through to check args */
775 }
777 {
782 /* else fall through to check args */
783 }
785 /*
786 * If you add any more cases that return sets, also fix
787 * expression_returns_set_rows() in clauses.c and IS_SRF_CALL() in
788 * tlist.c.
789 */
791 /* Avoid recursion for some cases that parser checks not to return a set */
800 context);
801 }
804 /*
805 * exprCollation -
806 * returns the Oid of the collation of the expression's result.
807 *
808 * Note: expression nodes that can invoke functions generally have an
809 * "inputcollid" field, which is what the function should use as collation.
810 * That is the resolved common collation of the node's inputs. It is often
811 * but not always the same as the result collation; in particular, if the
812 * function produces a non-collatable result type from collatable inputs
813 * or vice versa, the two are different.
814 */
815 Oid
817 {
818 Oid coll;
824 {
865 /* ScalarArrayOpExpr's result is boolean ... */
869 /* BoolExpr's result is boolean ... */
873 {
878 {
879 /* get the collation of subselect's first target column */
888 /* collation doesn't change if it's converted to array */
889 }
890 else
891 {
892 /* otherwise, SubLink's result is RECORD or BOOLEAN */
894 }
895 }
898 {
903 {
904 /* get the collation of subselect's first target column */
906 /* collation doesn't change if it's converted to array */
907 }
908 else
909 {
910 /* otherwise, SubPlan's result is RECORD or BOOLEAN */
912 }
913 }
916 {
919 /* subplans should all return the same thing */
921 }
927 /* FieldStore's result is composite ... */
940 /* ConvertRowtypeExpr's result is composite ... */
956 /* RowExpr's result is composite ... */
960 /* RowCompareExpr's result is boolean ... */
970 /* Returns either NAME or a non-collatable type */
973 else
978 /*
979 * XMLSERIALIZE returns text from non-collatable inputs, so its
980 * collation is always default. The other cases return boolean or
981 * XML, which are non-collatable.
982 */
985 else
992 {
997 else
999 }
1002 /* IS JSON's result is boolean ... */
1006 {
1010 }
1013 {
1018 else
1020 }
1023 /* NullTest's result is boolean ... */
1027 /* BooleanTest's result is boolean ... */
1040 /* CurrentOfExpr's result is boolean ... */
1044 /* NextValueExpr's result is an integer type ... */
1057 }
1059 }
1061 /*
1062 * exprInputCollation -
1063 * returns the Oid of the collation a function should use, if available.
1064 *
1065 * Result is InvalidOid if the node type doesn't store this information.
1066 */
1067 Oid
1069 {
1070 Oid coll;
1076 {
1104 }
1106 }
1108 /*
1109 * exprSetCollation -
1110 * Assign collation information to an expression tree node.
1111 *
1112 * Note: since this is only used during parse analysis, we don't need to
1113 * worry about subplans or PlaceHolderVars.
1114 */
1115 void
1117 {
1119 {
1160 /* ScalarArrayOpExpr's result is boolean ... */
1164 /* BoolExpr's result is boolean ... */
1168 #ifdef USE_ASSERT_CHECKING
1169 {
1174 {
1175 /* get the collation of subselect's first target column */
1184 }
1185 else
1186 {
1187 /* otherwise, result is RECORD or BOOLEAN */
1189 }
1190 }
1197 /* FieldStore's result is composite ... */
1210 /* ConvertRowtypeExpr's result is composite ... */
1220 /* RowExpr's result is composite ... */
1224 /* RowCompareExpr's result is boolean ... */
1245 collation);
1248 {
1253 else
1255 * json[b] type */
1256 }
1262 {
1266 }
1269 {
1274 }
1277 /* NullTest's result is boolean ... */
1281 /* BooleanTest's result is boolean ... */
1294 /* CurrentOfExpr's result is boolean ... */
1298 /* NextValueExpr's result is an integer type ... */
1304 }
1305 }
1307 /*
1308 * exprSetInputCollation -
1309 * Assign input-collation information to an expression tree node.
1310 *
1311 * This is a no-op for node types that don't store their input collation.
1312 * Note we omit RowCompareExpr, which needs special treatment since it
1313 * contains multiple input collation OIDs.
1314 */
1315 void
1317 {
1319 {
1346 }
1347 }
1350 /*
1351 * exprLocation -
1352 * returns the parse location of an expression tree, for error reports
1353 *
1354 * -1 is returned if the location can't be determined.
1355 *
1356 * For expressions larger than a single token, the intent here is to
1357 * return the location of the expression's leftmost token, not necessarily
1358 * the topmost Node's location field. For example, an OpExpr's location
1359 * field will point at the operator name, but if it is not a prefix operator
1360 * then we should return the location of the left-hand operand instead.
1361 * The reason is that we want to reference the entire expression not just
1362 * that operator, and pointing to its start seems to be the most natural way.
1363 *
1364 * The location is not perfect --- for example, since the grammar doesn't
1365 * explicitly represent parentheses in the parsetree, given something that
1366 * had been written "(a + b) * c" we are going to point at "a" not "(".
1367 * But it should be plenty good enough for error reporting purposes.
1368 *
1369 * You might think that this code is overly general, for instance why check
1370 * the operands of a FuncExpr node, when the function name can be expected
1371 * to be to the left of them? There are a couple of reasons. The grammar
1372 * sometimes builds expressions that aren't quite what the user wrote;
1373 * for instance x IS NOT BETWEEN ... becomes a NOT-expression whose keyword
1374 * pointer is to the right of its leftmost argument. Also, nodes that were
1375 * inserted implicitly by parse analysis (such as FuncExprs for implicit
1376 * coercions) will have location -1, and so we can have odd combinations of
1377 * known and unknown locations in a tree.
1378 */
1379 int
1381 {
1387 {
1404 /* function name should always be the first thing */
1411 /* function name should always be the first thing */
1418 /* just use container argument's location */
1422 {
1425 /* consider both function name and leftmost arg */
1428 }
1431 {
1434 /* consider both argument name and value */
1437 }
1442 {
1445 /* consider both operator name and leftmost arg */
1448 }
1451 {
1454 /* consider both operator name and leftmost arg */
1457 }
1460 {
1463 /*
1464 * Same as above, to handle either NOT or AND/OR. We can't
1465 * special-case NOT because of the way that it's used for
1466 * things like IS NOT BETWEEN.
1467 */
1470 }
1473 {
1476 /* check the testexpr, if any, and the operator/keyword */
1479 }
1482 /* just use argument's location */
1486 /* just use argument's location */
1490 {
1493 /* Much as above */
1496 }
1499 {
1502 /* Much as above */
1505 }
1508 {
1511 /* Much as above */
1514 }
1517 {
1520 /* Much as above */
1523 }
1526 /* just use argument's location */
1530 /* CASE keyword should always be the first thing */
1534 /* WHEN keyword should always be the first thing */
1538 /* the location points at ARRAY or [, which must be leftmost */
1542 /* the location points at ROW or (, which must be leftmost */
1546 /* just use leftmost argument's location */
1550 /* COALESCE keyword should always be the first thing */
1554 /* GREATEST/LEAST keyword should always be the first thing */
1558 /* function keyword should always be the first thing */
1562 {
1565 /* consider both function name and leftmost arg */
1568 }
1583 {
1586 /* consider both function name and leftmost arg */
1589 }
1595 {
1598 /* Much as above */
1601 }
1604 {
1607 /* Much as above */
1610 }
1613 {
1616 /* Much as above */
1619 }
1628 /* just use argument's location */
1632 /* use the contained RangeVar's location --- close enough */
1636 {
1637 /* report location of first list member that has a location */
1642 {
1646 }
1647 }
1650 {
1653 /* use leftmost of operator or left operand (if any) */
1654 /* we assume right operand can't be to left of operator */
1657 }
1669 {
1672 /* consider both function name and leftmost arg */
1673 /* (we assume any ORDER BY nodes must be to right of name) */
1676 }
1679 /* the location points at ARRAY or [, which must be leftmost */
1683 /* we need not examine the contained expression (if any) */
1690 {
1693 /*
1694 * This could represent CAST(), ::, or TypeName 'literal', so
1695 * any of the components might be leftmost.
1696 */
1700 }
1703 /* just use argument's location */
1707 /* just use argument's location (ignore operator, if any) */
1729 /* XMLSERIALIZE keyword should always be the first thing */
1754 /* just use the key's location */
1776 /* just use argument's location */
1780 /* just use nested expr's location */
1796 /* for any other node type it's just unknown... */
1799 }
1801 }
1803 /*
1804 * leftmostLoc - support for exprLocation
1805 *
1806 * Take the minimum of two parse location values, but ignore unknowns
1807 */
1808 static int
1810 {
1815 else
1817 }
1820 /*
1821 * fix_opfuncids
1822 * Calculate opfuncid field from opno for each OpExpr node in given tree.
1823 * The given tree can be anything expression_tree_walker handles.
1824 *
1825 * The argument is modified in-place. (This is OK since we'd want the
1826 * same change for any node, even if it gets visited more than once due to
1827 * shared structure.)
1828 */
1829 void
1831 {
1832 /* This tree walk requires no special setup, so away we go... */
1834 }
1836 static bool
1838 {
1850 }
1852 /*
1853 * set_opfuncid
1854 * Set the opfuncid (procedure OID) in an OpExpr node,
1855 * if it hasn't been set already.
1856 *
1857 * Because of struct equivalence, this can also be used for
1858 * DistinctExpr and NullIfExpr nodes.
1859 */
1860 void
1862 {
1865 }
1867 /*
1868 * set_sa_opfuncid
1869 * As above, for ScalarArrayOpExpr nodes.
1870 */
1871 void
1873 {
1876 }
1879 /*
1880 * check_functions_in_node -
1881 * apply checker() to each function OID contained in given expression node
1882 *
1883 * Returns true if the checker() function does; for nodes representing more
1884 * than one function call, returns true if the checker() function does so
1885 * for any of those functions. Returns false if node does not invoke any
1886 * SQL-visible function. Caller must not pass node == NULL.
1887 *
1888 * This function examines only the given node; it does not recurse into any
1889 * sub-expressions. Callers typically prefer to keep control of the recursion
1890 * for themselves, in case additional checks should be made, or because they
1891 * have special rules about which parts of the tree need to be visited.
1892 *
1893 * Note: we ignore MinMaxExpr, SQLValueFunction, XmlExpr, CoerceToDomain,
1894 * and NextValueExpr nodes, because they do not contain SQL function OIDs.
1895 * However, they can invoke SQL-visible functions, so callers should take
1896 * thought about how to treat them.
1897 */
1898 bool
1901 {
1903 {
1905 {
1910 }
1913 {
1918 }
1921 {
1926 }
1931 {
1934 /* Set opfuncid if it wasn't set already */
1938 }
1941 {
1947 }
1950 {
1952 Oid iofunc;
1953 Oid typioparam;
1956 /* check the result type's input function */
1961 /* check the input type's output function */
1966 }
1969 {
1974 {
1979 }
1980 }
1984 }
1986 }
1989 /*
1990 * Standard expression-tree walking support
1991 *
1992 * We used to have near-duplicate code in many different routines that
1993 * understood how to recurse through an expression node tree. That was
1994 * a pain to maintain, and we frequently had bugs due to some particular
1995 * routine neglecting to support a particular node type. In most cases,
1996 * these routines only actually care about certain node types, and don't
1997 * care about other types except insofar as they have to recurse through
1998 * non-primitive node types. Therefore, we now provide generic tree-walking
1999 * logic to consolidate the redundant "boilerplate" code. There are
2000 * two versions: expression_tree_walker() and expression_tree_mutator().
2001 */
2003 /*
2004 * expression_tree_walker() is designed to support routines that traverse
2005 * a tree in a read-only fashion (although it will also work for routines
2006 * that modify nodes in-place but never add/delete/replace nodes).
2007 * A walker routine should look like this:
2008 *
2009 * bool my_walker (Node *node, my_struct *context)
2010 * {
2011 * if (node == NULL)
2012 * return false;
2013 * // check for nodes that special work is required for, eg:
2014 * if (IsA(node, Var))
2015 * {
2016 * ... do special actions for Var nodes
2017 * }
2018 * else if (IsA(node, ...))
2019 * {
2020 * ... do special actions for other node types
2021 * }
2022 * // for any node type not specially processed, do:
2023 * return expression_tree_walker(node, my_walker, context);
2024 * }
2025 *
2026 * The "context" argument points to a struct that holds whatever context
2027 * information the walker routine needs --- it can be used to return data
2028 * gathered by the walker, too. This argument is not touched by
2029 * expression_tree_walker, but it is passed down to recursive sub-invocations
2030 * of my_walker. The tree walk is started from a setup routine that
2031 * fills in the appropriate context struct, calls my_walker with the top-level
2032 * node of the tree, and then examines the results.
2033 *
2034 * The walker routine should return "false" to continue the tree walk, or
2035 * "true" to abort the walk and immediately return "true" to the top-level
2036 * caller. This can be used to short-circuit the traversal if the walker
2037 * has found what it came for. "false" is returned to the top-level caller
2038 * iff no invocation of the walker returned "true".
2039 *
2040 * The node types handled by expression_tree_walker include all those
2041 * normally found in target lists and qualifier clauses during the planning
2042 * stage. In particular, it handles List nodes since a cnf-ified qual clause
2043 * will have List structure at the top level, and it handles TargetEntry nodes
2044 * so that a scan of a target list can be handled without additional code.
2045 * Also, RangeTblRef, FromExpr, JoinExpr, and SetOperationStmt nodes are
2046 * handled, so that query jointrees and setOperation trees can be processed
2047 * without additional code.
2048 *
2049 * expression_tree_walker will handle SubLink nodes by recursing normally
2050 * into the "testexpr" subtree (which is an expression belonging to the outer
2051 * plan). It will also call the walker on the sub-Query node; however, when
2052 * expression_tree_walker itself is called on a Query node, it does nothing
2053 * and returns "false". The net effect is that unless the walker does
2054 * something special at a Query node, sub-selects will not be visited during
2055 * an expression tree walk. This is exactly the behavior wanted in many cases
2056 * --- and for those walkers that do want to recurse into sub-selects, special
2057 * behavior is typically needed anyway at the entry to a sub-select (such as
2058 * incrementing a depth counter). A walker that wants to examine sub-selects
2059 * should include code along the lines of:
2060 *
2061 * if (IsA(node, Query))
2062 * {
2063 * adjust context for subquery;
2064 * result = query_tree_walker((Query *) node, my_walker, context,
2065 * 0); // adjust flags as needed
2066 * restore context if needed;
2067 * return result;
2068 * }
2069 *
2070 * query_tree_walker is a convenience routine (see below) that calls the
2071 * walker on all the expression subtrees of the given Query node.
2072 *
2073 * expression_tree_walker will handle SubPlan nodes by recursing normally
2074 * into the "testexpr" and the "args" list (which are expressions belonging to
2075 * the outer plan). It will not touch the completed subplan, however. Since
2076 * there is no link to the original Query, it is not possible to recurse into
2077 * subselects of an already-planned expression tree. This is OK for current
2078 * uses, but may need to be revisited in future.
2079 */
2081 bool
2083 tree_walker_callback walker,
2085 {
2088 /*
2089 * The walker has already visited the current node, and so we need only
2090 * recurse into any sub-nodes it has.
2091 *
2092 * We assume that the walker is not interested in List nodes per se, so
2093 * when we expect a List we just recurse directly to self without
2094 * bothering to call the walker.
2095 */
2096 #define WALK(n) walker((Node *) (n), context)
2098 #define LIST_WALK(l) expression_tree_walker_impl((Node *) (l), walker, context)
2103 /* Guard against stack overflow due to overly complex expressions */
2107 {
2121 /* primitive node types with no expression subnodes */
2126 {
2129 /* recurse directly on Lists */
2140 }
2143 {
2148 }
2151 {
2154 /* recurse directly on List */
2161 }
2164 {
2169 }
2172 {
2175 /* recurse directly for upper/lower container index lists */
2180 /* walker must see the refexpr and refassgnexpr, however */
2186 }
2189 {
2194 }
2201 {
2206 }
2209 {
2214 }
2217 {
2222 }
2225 {
2231 /*
2232 * Also invoke the walker on the sublink's Query node, so it
2233 * can recurse into the sub-query if it wants to.
2234 */
2236 }
2239 {
2242 /* recurse into the testexpr, but not into the Plan */
2245 /* also examine args list */
2248 }
2255 {
2262 }
2269 {
2276 }
2283 {
2288 /* we assume walker doesn't care about CaseWhens, either */
2290 {
2297 }
2300 }
2305 /* Assume colnames isn't interesting */
2308 {
2315 }
2322 {
2327 /* we assume walker doesn't care about arg_names */
2330 }
2333 {
2340 }
2343 {
2352 }
2357 {
2366 /* we assume walker doesn't care about passing_names */
2371 }
2374 {
2379 }
2390 /* Do nothing with a sub-Query, per discussion above */
2393 {
2404 }
2407 {
2414 }
2417 {
2420 /*
2421 * Invoke the walker on the CTE's Query node, so it can
2422 * recurse into the sub-query if it wants to.
2423 */
2431 }
2434 {
2441 }
2444 {
2449 }
2452 {
2457 }
2460 {
2465 }
2468 {
2477 }
2480 {
2487 }
2490 {
2497 }
2501 {
2510 }
2513 {
2518 }
2522 {
2525 }
2528 {
2535 }
2538 {
2551 }
2554 {
2561 }
2564 {
2569 }
2572 /* no expression subnodes */
2575 {
2585 /*
2586 * alias clause, using list are deemed uninteresting.
2587 */
2588 }
2591 {
2599 /* groupClauses are deemed uninteresting */
2600 }
2603 {
2610 }
2617 {
2622 }
2629 {
2636 }
2639 {
2656 }
2662 }
2665 /* The WALK() macro can be re-used below, but LIST_WALK() not so much */
2666 #undef LIST_WALK
2667 }
2669 /*
2670 * query_tree_walker --- initiate a walk of a Query's expressions
2671 *
2672 * This routine exists just to reduce the number of places that need to know
2673 * where all the expression subtrees of a Query are. Note it can be used
2674 * for starting a walk at top level of a Query regardless of whether the
2675 * walker intends to descend into subqueries. It is also useful for
2676 * descending into subqueries within a walker.
2677 *
2678 * Some callers want to suppress visitation of certain items in the sub-Query,
2679 * typically because they need to process them specially, or don't actually
2680 * want to recurse into subqueries. This is supported by the flags argument,
2681 * which is the bitwise OR of flag values to add or suppress visitation of
2682 * indicated items. (More flag bits may be added as needed.)
2683 */
2684 bool
2686 tree_walker_callback walker,
2689 {
2692 /*
2693 * We don't walk any utilityStmt here. However, we can't easily assert
2694 * that it is absent, since there are at least two code paths by which
2695 * action statements from CREATE RULE end up here, and NOTIFY is allowed
2696 * in a rule action.
2697 */
2722 /*
2723 * Most callers aren't interested in SortGroupClause nodes since those
2724 * don't contain actual expressions. However they do contain OIDs which
2725 * may be needed by dependency walkers etc.
2726 */
2728 {
2737 }
2738 else
2739 {
2740 /*
2741 * But we need to walk the expressions under WindowClause nodes even
2742 * if we're not interested in SortGroupClause nodes.
2743 */
2747 {
2754 }
2755 }
2757 /*
2758 * groupingSets and rowMarks are not walked:
2759 *
2760 * groupingSets contain only ressortgrouprefs (integers) which are
2761 * meaningless without the corresponding groupClause or tlist.
2762 * Accordingly, any walker that needs to care about them needs to handle
2763 * them itself in its Query processing.
2764 *
2765 * rowMarks is not walked because it contains only rangetable indexes (and
2766 * flags etc.) and therefore should be handled at Query level similarly.
2767 */
2770 {
2773 }
2775 {
2778 }
2780 }
2782 /*
2783 * range_table_walker is just the part of query_tree_walker that scans
2784 * a query's rangetable. This is split out since it can be useful on
2785 * its own.
2786 */
2787 bool
2789 tree_walker_callback walker,
2792 {
2796 {
2801 }
2803 }
2805 /*
2806 * Some callers even want to scan the expressions in individual RTEs.
2807 */
2808 bool
2810 tree_walker_callback walker,
2813 {
2814 /*
2815 * Walkers might need to examine the RTE node itself either before or
2816 * after visiting its contents (or, conceivably, both). Note that if you
2817 * specify neither flag, the walker won't be called on the RTE at all.
2818 */
2824 {
2854 /* nothing to do */
2861 }
2871 }
2874 /*
2875 * expression_tree_mutator() is designed to support routines that make a
2876 * modified copy of an expression tree, with some nodes being added,
2877 * removed, or replaced by new subtrees. The original tree is (normally)
2878 * not changed. Each recursion level is responsible for returning a copy of
2879 * (or appropriately modified substitute for) the subtree it is handed.
2880 * A mutator routine should look like this:
2881 *
2882 * Node * my_mutator (Node *node, my_struct *context)
2883 * {
2884 * if (node == NULL)
2885 * return NULL;
2886 * // check for nodes that special work is required for, eg:
2887 * if (IsA(node, Var))
2888 * {
2889 * ... create and return modified copy of Var node
2890 * }
2891 * else if (IsA(node, ...))
2892 * {
2893 * ... do special transformations of other node types
2894 * }
2895 * // for any node type not specially processed, do:
2896 * return expression_tree_mutator(node, my_mutator, context);
2897 * }
2898 *
2899 * The "context" argument points to a struct that holds whatever context
2900 * information the mutator routine needs --- it can be used to return extra
2901 * data gathered by the mutator, too. This argument is not touched by
2902 * expression_tree_mutator, but it is passed down to recursive sub-invocations
2903 * of my_mutator. The tree walk is started from a setup routine that
2904 * fills in the appropriate context struct, calls my_mutator with the
2905 * top-level node of the tree, and does any required post-processing.
2906 *
2907 * Each level of recursion must return an appropriately modified Node.
2908 * If expression_tree_mutator() is called, it will make an exact copy
2909 * of the given Node, but invoke my_mutator() to copy the sub-node(s)
2910 * of that Node. In this way, my_mutator() has full control over the
2911 * copying process but need not directly deal with expression trees
2912 * that it has no interest in.
2913 *
2914 * Just as for expression_tree_walker, the node types handled by
2915 * expression_tree_mutator include all those normally found in target lists
2916 * and qualifier clauses during the planning stage.
2917 *
2918 * expression_tree_mutator will handle SubLink nodes by recursing normally
2919 * into the "testexpr" subtree (which is an expression belonging to the outer
2920 * plan). It will also call the mutator on the sub-Query node; however, when
2921 * expression_tree_mutator itself is called on a Query node, it does nothing
2922 * and returns the unmodified Query node. The net effect is that unless the
2923 * mutator does something special at a Query node, sub-selects will not be
2924 * visited or modified; the original sub-select will be linked to by the new
2925 * SubLink node. Mutators that want to descend into sub-selects will usually
2926 * do so by recognizing Query nodes and calling query_tree_mutator (below).
2927 *
2928 * expression_tree_mutator will handle a SubPlan node by recursing into the
2929 * "testexpr" and the "args" list (which belong to the outer plan), but it
2930 * will simply copy the link to the inner plan, since that's typically what
2931 * expression tree mutators want. A mutator that wants to modify the subplan
2932 * can force appropriate behavior by recognizing SubPlan expression nodes
2933 * and doing the right thing.
2934 */
2936 Node *
2938 tree_mutator_callback mutator,
2940 {
2941 /*
2942 * The mutator has already decided not to modify the current node, but we
2943 * must call the mutator for any sub-nodes.
2944 */
2946 #define FLATCOPY(newnode, node, nodetype) \
2947 ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \
2948 memcpy((newnode), (node), sizeof(nodetype)) )
2950 #define MUTATE(newfield, oldfield, fieldtype) \
2951 ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )
2956 /* Guard against stack overflow due to overly complex expressions */
2960 {
2961 /*
2962 * Primitive node types with no expression subnodes. Var and
2963 * Const are frequent enough to deserve special cases, the others
2964 * we just use copyObject for.
2965 */
2967 {
2972 /* Assume we need not copy the varnullingrels bitmapset */
2974 }
2977 {
2982 /* XXX we don't bother with datumCopy; should we? */
2984 }
3000 {
3007 }
3009 {
3014 /* assume mutation doesn't change types of arguments */
3022 }
3025 {
3032 /*
3033 * We assume here that mutating the arguments does not change
3034 * the semantics, i.e. that the arguments are not mutated in a
3035 * way that makes them semantically different from their
3036 * previously matching expressions in the GROUP BY clause.
3037 *
3038 * If a mutator somehow wanted to do this, it would have to
3039 * handle the refs and cols lists itself as appropriate.
3040 */
3045 }
3048 {
3056 }
3059 {
3066 }
3069 {
3075 List *);
3077 List *);
3079 Expr *);
3081 Expr *);
3084 }
3087 {
3094 }
3097 {
3104 }
3107 {
3114 }
3117 {
3124 }
3127 {
3134 }
3137 {
3144 }
3147 {
3154 }
3157 {
3164 /*
3165 * Also invoke the mutator on the sublink's Query node, so it
3166 * can recurse into the sub-query if it wants to.
3167 */
3170 }
3173 {
3178 /* transform testexpr */
3180 /* transform args list (params to be passed to subplan) */
3182 /* but not the sub-Plan itself, which is referenced as-is */
3184 }
3187 {
3194 }
3197 {
3204 }
3207 {
3216 }
3219 {
3226 }
3229 {
3236 }
3239 {
3247 }
3250 {
3257 }
3260 {
3267 }
3270 {
3279 }
3282 {
3290 }
3293 {
3300 }
3303 {
3309 /* Assume colnames needn't be duplicated */
3311 }
3314 {
3322 }
3325 {
3332 }
3335 {
3342 }
3345 {
3351 /* assume mutator does not care about arg_names */
3354 }
3357 {
3365 }
3367 {
3377 }
3379 {
3390 }
3392 {
3401 }
3403 {
3411 /* assume mutator does not care about passing_names */
3415 }
3418 {
3425 }
3428 {
3435 }
3438 {
3445 }
3448 {
3455 }
3458 {
3465 }
3468 /* Do nothing with a sub-Query, per discussion above */
3471 {
3481 }
3484 {
3492 }
3495 {
3501 /*
3502 * Also invoke the mutator on the CTE's Query node, so it can
3503 * recurse into the sub-query if it wants to.
3504 */
3511 }
3514 {
3523 }
3526 {
3533 }
3536 {
3537 /*
3538 * We assume the mutator isn't interested in the list nodes
3539 * per se, so just invoke it on each list element. NOTE: this
3540 * would fail badly on a list with integer elements!
3541 */
3547 {
3550 context));
3551 }
3553 }
3556 {
3564 }
3567 {
3579 }
3582 {
3591 }
3594 {
3602 }
3605 /* no expression sub-nodes */
3608 {
3616 /* We do not mutate alias or using by default */
3618 }
3621 {
3628 /* We do not mutate groupClauses by default */
3630 }
3633 {
3641 }
3644 {
3650 /* Assume we need not copy the relids bitmapsets */
3652 }
3655 {
3662 }
3665 {
3671 /* Assume nothing need be done with parent_colnos[] */
3673 }
3676 {
3682 /* Assume we need not copy the relids bitmapsets */
3684 }
3687 {
3693 /* Assume we need not copy the coldef info lists */
3695 }
3698 {
3706 }
3709 {
3722 }
3728 }
3729 /* can't get here, but keep compiler happy */
3731 }
3734 /*
3735 * query_tree_mutator --- initiate modification of a Query's expressions
3736 *
3737 * This routine exists just to reduce the number of places that need to know
3738 * where all the expression subtrees of a Query are. Note it can be used
3739 * for starting a walk at top level of a Query regardless of whether the
3740 * mutator intends to descend into subqueries. It is also useful for
3741 * descending into subqueries within a mutator.
3742 *
3743 * Some callers want to suppress mutating of certain items in the Query,
3744 * typically because they need to process them specially, or don't actually
3745 * want to recurse into subqueries. This is supported by the flags argument,
3746 * which is the bitwise OR of flag values to suppress mutating of
3747 * indicated items. (More flag bits may be added as needed.)
3748 *
3749 * Normally the top-level Query node itself is copied, but some callers want
3750 * it to be modified in-place; they must pass QTW_DONT_COPY_QUERY in flags.
3751 * All modified substructure is safely copied in any case.
3752 */
3753 Query *
3755 tree_mutator_callback mutator,
3758 {
3762 {
3767 }
3781 /*
3782 * Most callers aren't interested in SortGroupClause nodes since those
3783 * don't contain actual expressions. However they do contain OIDs, which
3784 * may be of interest to some mutators.
3785 */
3788 {
3793 }
3794 else
3795 {
3796 /*
3797 * But we need to mutate the expressions under WindowClause nodes even
3798 * if we're not interested in SortGroupClause nodes.
3799 */
3805 {
3814 }
3816 }
3818 /*
3819 * groupingSets and rowMarks are not mutated:
3820 *
3821 * groupingSets contain only ressortgroup refs (integers) which are
3822 * meaningless without the groupClause or tlist. Accordingly, any mutator
3823 * that needs to care about them needs to handle them itself in its Query
3824 * processing.
3825 *
3826 * rowMarks contains only rangetable indexes (and flags etc.) and
3827 * therefore should be handled at Query level similarly.
3828 */
3837 }
3839 /*
3840 * range_table_mutator is just the part of query_tree_mutator that processes
3841 * a query's rangetable. This is split out since it can be useful on
3842 * its own.
3843 */
3844 List *
3846 tree_mutator_callback mutator,
3849 {
3854 {
3860 {
3863 TableSampleClause *);
3864 /* we don't bother to copy eref, aliases, etc; OK? */
3869 else
3870 {
3871 /* else, copy RT subqueries as-is */
3873 }
3878 else
3879 {
3880 /* else, copy join aliases as-is */
3882 }
3896 /* nothing to do */
3901 else
3902 {
3903 /* else, copy grouping exprs as-is */
3905 }
3907 }
3910 }
3912 }
3914 /*
3915 * query_or_expression_tree_walker --- hybrid form
3916 *
3917 * This routine will invoke query_tree_walker if called on a Query node,
3918 * else will invoke the walker directly. This is a useful way of starting
3919 * the recursion when the walker's normal change of state is not appropriate
3920 * for the outermost Query node.
3921 */
3922 bool
3924 tree_walker_callback walker,
3927 {
3930 walker,
3931 context,
3932 flags);
3933 else
3935 }
3937 /*
3938 * query_or_expression_tree_mutator --- hybrid form
3939 *
3940 * This routine will invoke query_tree_mutator if called on a Query node,
3941 * else will invoke the mutator directly. This is a useful way of starting
3942 * the recursion when the mutator's normal change of state is not appropriate
3943 * for the outermost Query node.
3944 */
3945 Node *
3947 tree_mutator_callback mutator,
3950 {
3953 mutator,
3954 context,
3955 flags);
3956 else
3958 }
3961 /*
3962 * raw_expression_tree_walker --- walk raw parse trees
3963 *
3964 * This has exactly the same API as expression_tree_walker, but instead of
3965 * walking post-analysis parse trees, it knows how to walk the node types
3966 * found in raw grammar output. (There is not currently any need for a
3967 * combined walker, so we keep them separate in the name of efficiency.)
3968 * Unlike expression_tree_walker, there is no special rule about query
3969 * boundaries: we descend to everything that's possibly interesting.
3970 *
3971 * Currently, the node type coverage here extends only to DML statements
3972 * (SELECT/INSERT/UPDATE/DELETE/MERGE) and nodes that can appear in them,
3973 * because this is used mainly during analysis of CTEs, and only DML
3974 * statements can appear in CTEs.
3975 */
3976 bool
3978 tree_walker_callback walker,
3980 {
3983 /*
3984 * The walker has already visited the current node, and so we need only
3985 * recurse into any sub-nodes it has.
3986 */
3990 /* Guard against stack overflow due to overly complex expressions */
3994 {
4008 /* primitive node types with no subnodes */
4011 /* we assume the colnames list isn't interesting */
4018 {
4023 /* we assume the operName is not interesting */
4026 }
4029 {
4034 /* we assume walker doesn't care about CaseWhens, either */
4036 {
4043 }
4046 }
4049 /* Assume colnames isn't interesting */
4056 {
4061 /* we assume walker doesn't care about arg_names */
4064 }
4069 {
4078 }
4081 {
4088 }
4091 {
4098 }
4101 {
4108 }
4111 {
4122 }
4129 {
4144 }
4147 {
4152 }
4155 {
4168 }
4171 {
4182 }
4191 {
4202 /* using list is deemed uninteresting */
4203 }
4206 {
4211 /* colNames, options are deemed uninteresting */
4212 /* viewQuery should be null in raw parsetree, but check it */
4215 }
4219 {
4222 }
4225 {
4240 }
4243 {
4256 }
4259 {
4274 }
4277 {
4292 }
4295 {
4304 }
4307 {
4342 }
4345 {
4352 }
4355 {
4362 /* operator name is deemed uninteresting */
4363 }
4366 {
4371 }
4374 /* we assume the fields contain nothing interesting */
4377 {
4388 /* function name is deemed uninteresting */
4389 }
4394 {
4401 }
4404 {
4411 }
4416 {
4423 }
4428 {
4435 }
4442 {
4453 }
4456 {
4463 }
4466 {
4475 }
4478 {
4483 /* method name is deemed uninteresting */
4488 }
4491 {
4504 }
4507 {
4514 }
4517 {
4524 /* type name itself is deemed uninteresting */
4525 }
4528 {
4537 /* for now, constraints are ignored */
4538 }
4541 {
4546 /* collation and opclass names are deemed uninteresting */
4547 }
4554 {
4561 }
4566 {
4573 }
4576 {
4585 }
4588 /* search_clause and cycle_clause are not interesting here */
4591 {
4598 }
4601 {
4608 }
4611 {
4618 }
4621 {
4628 }
4631 {
4642 }
4645 {
4652 }
4655 {
4662 }
4665 {
4672 }
4678 }
4680 }
4682 /*
4683 * planstate_tree_walker --- walk plan state trees
4684 *
4685 * The walker has already visited the current node, and so we need only
4686 * recurse into any sub-nodes it has.
4687 */
4688 bool
4690 planstate_tree_walker_callback walker,
4692 {
4696 /* We don't need implicit coercions to Node here */
4697 #define PSWALK(n) walker(n, context)
4699 /* Guard against stack overflow due to overly complex plan trees */
4702 /* initPlan-s */
4706 /* lefttree */
4708 {
4711 }
4713 /* righttree */
4715 {
4718 }
4720 /* special child plans */
4722 {
4753 {
4756 }
4760 }
4762 /* subPlan-s */
4767 }
4769 /*
4770 * Walk a list of SubPlans (or initPlans, which also use SubPlan nodes).
4771 */
4772 static bool
4774 planstate_tree_walker_callback walker,
4776 {
4780 {
4785 }
4788 }
4790 /*
4791 * Walk the constituent plans of a ModifyTable, Append, MergeAppend,
4792 * BitmapAnd, or BitmapOr node.
4793 */
4794 static bool
4796 planstate_tree_walker_callback walker,
4798 {
4802 {
4805 }
4808 }