| blob | 6e7dc3d2df9820bbcb7019879720a462a37a25c3 |
1 /*-------------------------------------------------------------------------
2 *
3 * deparse.c
4 * Query deparser for postgres_fdw
5 *
6 * This file includes functions that examine query WHERE clauses to see
7 * whether they're safe to send to the remote server for execution, as
8 * well as functions to construct the query text to be sent. The latter
9 * functionality is annoyingly duplicative of ruleutils.c, but there are
10 * enough special considerations that it seems best to keep this separate.
11 * One saving grace is that we only need deparse logic for node types that
12 * we consider safe to send.
13 *
14 * We assume that the remote session's search_path is exactly "pg_catalog",
15 * and thus we need schema-qualify all and only names outside pg_catalog.
16 *
17 * We do not consider that it is ever safe to send COLLATE expressions to
18 * the remote server: it might not have the same collation names we do.
19 * (Later we might consider it safe to send COLLATE "C", but even that would
20 * fail on old remote servers.) An expression is considered safe to send
21 * only if all operator/function input collations used in it are traceable to
22 * Var(s) of the foreign table. That implies that if the remote server gets
23 * a different answer than we do, the foreign table's columns are not marked
24 * with collations that match the remote table's columns, which we can
25 * consider to be user error.
26 *
27 * Portions Copyright (c) 2012-2025, PostgreSQL Global Development Group
28 *
29 * IDENTIFICATION
30 * contrib/postgres_fdw/deparse.c
31 *
32 *-------------------------------------------------------------------------
33 */
63 /*
64 * Global context for foreign_expr_walker's search of an expression tree.
65 */
67 {
71 * scan */
74 /*
75 * Local (per-tree-level) context for foreign_expr_walker's search.
76 * This is concerned with identifying collations used in the expression.
77 */
79 {
81 * it has default collation that is not
82 * traceable to a foreign Var */
85 * something other than a foreign Var */
89 {
94 /*
95 * Context for deparseExpr
96 */
98 {
102 * foreignrel, when that represents a join or
103 * a base relation. */
109 /* Handy macro to add relation name qualification */
110 #define ADD_REL_QUALIFIER(buf, varno) \
115 /*
116 * Functions to determine whether an expression can be evaluated safely on
117 * remote server.
118 */
125 /*
126 * Functions to construct string representation of a node tree.
127 */
130 Index rtindex,
131 Relation rel,
200 /*
201 * Helper functions
202 */
209 /*
210 * Examine each qual clause in input_conds, and classify them into two groups,
211 * which are returned as two lists:
212 * - remote_conds contains expressions that can be evaluated remotely
213 * - local_conds contains expressions that can't be evaluated remotely
214 */
215 void
221 {
228 {
233 else
235 }
236 }
238 /*
239 * Returns true if given expr is safe to evaluate on the foreign server.
240 */
241 bool
245 {
246 foreign_glob_cxt glob_cxt;
247 foreign_loc_cxt loc_cxt;
250 /*
251 * Check that the expression consists of nodes that are safe to execute
252 * remotely.
253 */
257 /*
258 * For an upper relation, use relids from its underneath scan relation,
259 * because the upperrel's own relids currently aren't set to anything
260 * meaningful by the core code. For other relation, use their own relids.
261 */
264 else
271 /*
272 * If the expression has a valid collation that does not arise from a
273 * foreign var, the expression can not be sent over.
274 */
278 /*
279 * An expression which includes any mutable functions can't be sent over
280 * because its result is not stable. For example, sending now() remote
281 * side could cause confusion from clock offsets. Future versions might
282 * be able to make this choice with more granularity. (We check this last
283 * because it requires a lot of expensive catalog lookups.)
284 */
288 /* OK to evaluate on the remote server */
290 }
292 /*
293 * Check if expression is safe to execute remotely, and return true if so.
294 *
295 * In addition, *outer_cxt is updated with collation information.
296 *
297 * case_arg_cxt is NULL if this subexpression is not inside a CASE-with-arg.
298 * Otherwise, it points to the collation info derived from the arg expression,
299 * which must be consulted by any CaseTestExpr.
300 *
301 * We must check that the expression contains only node types we can deparse,
302 * that all types/functions/operators are safe to send (they are "shippable"),
303 * and that all collations used in the expression derive from Vars of the
304 * foreign table. Because of the latter, the logic is pretty close to
305 * assign_collations_walker() in parse_collate.c, though we can assume here
306 * that the given expression is valid. Note function mutability is not
307 * currently considered here.
308 */
309 static bool
314 {
317 foreign_loc_cxt inner_cxt;
318 Oid collation;
319 FDWCollateState state;
321 /* Need do nothing for empty subexpressions */
325 /* May need server info from baserel's fdw_private struct */
328 /* Set up inner_cxt for possible recursion to child nodes */
333 {
335 {
338 /*
339 * If the Var is from the foreign table, we consider its
340 * collation (if any) safe to use. If it is from another
341 * table, we treat its collation the same way as we would a
342 * Param's collation, ie it's not safe for it to have a
343 * non-default collation.
344 */
347 {
348 /* Var belongs to foreign table */
350 /*
351 * System columns other than ctid should not be sent to
352 * the remote, since we don't make any effort to ensure
353 * that local and remote values match (tableoid, in
354 * particular, almost certainly doesn't match).
355 */
360 /* Else check the collation */
363 }
364 else
365 {
366 /* Var belongs to some other table */
370 {
371 /*
372 * It's noncollatable, or it's safe to combine with a
373 * collatable foreign Var, so set state to NONE.
374 */
376 }
377 else
378 {
379 /*
380 * Do not fail right away, since the Var might appear
381 * in a collation-insensitive context.
382 */
384 }
385 }
386 }
389 {
392 /*
393 * Constants of regproc and related types can't be shipped
394 * unless the referenced object is shippable. But NULL's ok.
395 * (See also the related code in dependency.c.)
396 */
398 {
400 {
430 /*
431 * For text search objects only, we weaken the
432 * normal shippability criterion to allow all OIDs
433 * below FirstNormalObjectId. Without this, none
434 * of the initdb-installed TS configurations would
435 * be shippable, which would be quite annoying.
436 */
458 }
459 }
461 /*
462 * If the constant has nondefault collation, either it's of a
463 * non-builtin type, or it reflects folding of a CollateExpr.
464 * It's unsafe to send to the remote unless it's used in a
465 * non-collation-sensitive context.
466 */
471 else
473 }
476 {
479 /*
480 * If it's a MULTIEXPR Param, punt. We can't tell from here
481 * whether the referenced sublink/subplan contains any remote
482 * Vars; if it does, handling that is too complicated to
483 * consider supporting at present. Fortunately, MULTIEXPR
484 * Params are not reduced to plain PARAM_EXEC until the end of
485 * planning, so we can easily detect this case. (Normal
486 * PARAM_EXEC Params are safe to ship because their values
487 * come from somewhere else in the plan tree; but a MULTIEXPR
488 * references a sub-select elsewhere in the same targetlist,
489 * so we'd be on the hook to evaluate it somehow if we wanted
490 * to handle such cases as direct foreign updates.)
491 */
495 /*
496 * Collation rule is same as for Consts and non-foreign Vars.
497 */
502 else
504 }
507 {
510 /* Assignment should not be in restrictions. */
514 /*
515 * Recurse into the remaining subexpressions. The container
516 * subscripts will not affect collation of the SubscriptingRef
517 * result, so do those first and reset inner_cxt afterwards.
518 */
533 /*
534 * Container subscripting typically yields same collation as
535 * refexpr's, but in case it doesn't, use same logic as for
536 * function nodes.
537 */
546 else
548 }
551 {
554 /*
555 * If function used by the expression is not shippable, it
556 * can't be sent to remote because it might have incompatible
557 * semantics on remote side.
558 */
562 /*
563 * Recurse to input subexpressions.
564 */
569 /*
570 * If function's input collation is not derived from a foreign
571 * Var, it can't be sent to remote.
572 */
579 /*
580 * Detect whether node is introducing a collation not derived
581 * from a foreign Var. (If so, we just mark it unsafe for now
582 * rather than immediately returning false, since the parent
583 * node might not care.)
584 */
593 else
595 }
599 {
602 /*
603 * Similarly, only shippable operators can be sent to remote.
604 * (If the operator is shippable, we assume its underlying
605 * function is too.)
606 */
610 /*
611 * Recurse to input subexpressions.
612 */
617 /*
618 * If operator's input collation is not derived from a foreign
619 * Var, it can't be sent to remote.
620 */
627 /* Result-collation handling is same as for functions */
636 else
638 }
641 {
644 /*
645 * Again, only shippable operators can be sent to remote.
646 */
650 /*
651 * Recurse to input subexpressions.
652 */
657 /*
658 * If operator's input collation is not derived from a foreign
659 * Var, it can't be sent to remote.
660 */
667 /* Output is always boolean and so noncollatable. */
670 }
673 {
676 /*
677 * Recurse to input subexpression.
678 */
683 /*
684 * RelabelType must not introduce a collation not derived from
685 * an input foreign Var (same logic as for a real function).
686 */
695 else
697 }
700 {
703 /*
704 * Recurse to input subexpressions.
705 */
710 /* Output is always boolean and so noncollatable. */
713 }
716 {
719 /*
720 * Recurse to input subexpressions.
721 */
726 /* Output is always boolean and so noncollatable. */
729 }
732 {
734 foreign_loc_cxt arg_cxt;
735 foreign_loc_cxt tmp_cxt;
738 /*
739 * Recurse to CASE's arg expression, if any. Its collation
740 * has to be saved aside for use while examining CaseTestExprs
741 * within the WHEN expressions.
742 */
746 {
750 }
752 /* Examine the CaseWhen subexpressions. */
754 {
758 {
759 /*
760 * In a CASE-with-arg, the parser should have produced
761 * WHEN clauses of the form "CaseTestExpr = RHS",
762 * possibly with an implicit coercion inserted above
763 * the CaseTestExpr. However in an expression that's
764 * been through the optimizer, the WHEN clause could
765 * be almost anything (since the equality operator
766 * could have been expanded into an inline function).
767 * In such cases forbid pushdown, because
768 * deparseCaseExpr can't handle it.
769 */
779 CaseTestExpr))
781 }
783 /*
784 * Recurse to WHEN expression, passing down the arg info.
785 * Its collation doesn't affect the result (really, it
786 * should be boolean and thus not have a collation).
787 */
794 /* Recurse to THEN expression. */
798 }
800 /* Recurse to ELSE expression. */
805 /*
806 * Detect whether node is introducing a collation not derived
807 * from a foreign Var. (If so, we just mark it unsafe for now
808 * rather than immediately returning false, since the parent
809 * node might not care.) This is the same as for function
810 * nodes, except that the input collation is derived from only
811 * the THEN and ELSE subexpressions.
812 */
821 else
823 }
826 {
829 /* Punt if we seem not to be inside a CASE arg WHEN. */
833 /*
834 * Otherwise, any nondefault collation attached to the
835 * CaseTestExpr node must be derived from foreign Var(s) in
836 * the CASE arg.
837 */
846 else
848 }
851 {
854 /*
855 * Recurse to input subexpressions.
856 */
861 /*
862 * ArrayExpr must not introduce a collation not derived from
863 * an input foreign Var (same logic as for a function).
864 */
873 else
875 }
878 {
882 /*
883 * Recurse to component subexpressions.
884 */
886 {
890 }
892 /*
893 * When processing a list, collation state just bubbles up
894 * from the list elements.
895 */
899 /* Don't apply exprType() to the list. */
901 }
904 {
908 /* Not safe to pushdown when not in grouping context */
912 /* Only non-split aggregates are pushable. */
916 /* As usual, it must be shippable. */
920 /*
921 * Recurse to input args. aggdirectargs, aggorder and
922 * aggdistinct are all present in args, so no need to check
923 * their shippability explicitly.
924 */
926 {
929 /* If TargetEntry, extract the expression from it */
931 {
935 }
940 }
942 /*
943 * For aggorder elements, check whether the sort operator, if
944 * specified, is shippable or not.
945 */
947 {
949 {
951 Oid sortcoltype;
960 /* Check shippability of non-default sort operator. */
964 fpinfo))
966 }
967 }
969 /* Check aggregate filter */
974 /*
975 * If aggregate's input collation is not derived from a
976 * foreign Var, it can't be sent to remote.
977 */
984 /*
985 * Detect whether node is introducing a collation not derived
986 * from a foreign Var. (If so, we just mark it unsafe for now
987 * rather than immediately returning false, since the parent
988 * node might not care.)
989 */
998 else
1000 }
1004 /*
1005 * If it's anything else, assume it's unsafe. This list can be
1006 * expanded later, but don't forget to add deparse support below.
1007 */
1009 }
1011 /*
1012 * If result type of given expression is not shippable, it can't be sent
1013 * to remote because it might have incompatible semantics on remote side.
1014 */
1018 /*
1019 * Now, merge my collation information into my parent's state.
1020 */
1022 {
1023 /* Override previous parent state */
1026 }
1028 {
1029 /* Merge, or detect error if there's a collation conflict */
1031 {
1033 /* Nothing + nothing is still nothing */
1037 {
1038 /*
1039 * Non-default collation always beats default.
1040 */
1042 {
1043 /* Override previous parent state */
1045 }
1047 {
1048 /*
1049 * Conflict; show state as indeterminate. We don't
1050 * want to "return false" right away, since parent
1051 * node might not care about collation.
1052 */
1054 }
1055 }
1058 /* We're still conflicted ... */
1060 }
1061 }
1063 /* It looks OK */
1065 }
1067 /*
1068 * Returns true if given expr is something we'd have to send the value of
1069 * to the foreign server.
1070 *
1071 * This should return true when the expression is a shippable node that
1072 * deparseExpr would add to context->params_list. Note that we don't care
1073 * if the expression *contains* such a node, only whether one appears at top
1074 * level. We need this to detect cases where setrefs.c would recognize a
1075 * false match between an fdw_exprs item (which came from the params_list)
1076 * and an entry in fdw_scan_tlist (which we're considering putting the given
1077 * expression into).
1078 */
1079 bool
1083 {
1088 {
1090 {
1091 /* It would have to be sent unless it's a foreign Var */
1094 Relids relids;
1098 else
1103 else
1106 }
1108 /* Params always have to be sent to the foreign server */
1112 }
1114 }
1116 /*
1117 * Returns true if it's safe to push down the sort expression described by
1118 * 'pathkey' to the foreign server.
1119 */
1120 bool
1124 {
1128 /*
1129 * is_foreign_expr would detect volatile expressions as well, but checking
1130 * ec_has_volatile here saves some cycles.
1131 */
1135 /* can't push down the sort if the pathkey's opfamily is not shippable */
1139 /* can push if a suitable EC member exists */
1141 }
1143 /*
1144 * Convert type OID + typmod info into a type name we can ship to the remote
1145 * server. Someplace else had better have verified that this type name is
1146 * expected to be known on the remote end.
1147 *
1148 * This is almost just format_type_with_typemod(), except that if left to its
1149 * own devices, that function will make schema-qualification decisions based
1150 * on the local search_path, which is wrong. We must schema-qualify all
1151 * type names that are not in pg_catalog. We assume here that built-in types
1152 * are all in pg_catalog and need not be qualified; otherwise, qualify.
1153 */
1156 {
1163 }
1165 /*
1166 * Build the targetlist for given relation to be deparsed as SELECT clause.
1167 *
1168 * The output targetlist contains the columns that need to be fetched from the
1169 * foreign server for the given relation. If foreignrel is an upper relation,
1170 * then the output targetlist can also contain expressions to be evaluated on
1171 * foreign server.
1172 */
1173 List *
1175 {
1180 /*
1181 * For an upper relation, we have already built the target list while
1182 * checking shippability, so just return that.
1183 */
1187 /*
1188 * We require columns specified in foreignrel->reltarget->exprs and those
1189 * required for evaluating the local conditions.
1190 */
1193 PVC_RECURSE_PLACEHOLDERS));
1195 {
1200 PVC_RECURSE_PLACEHOLDERS));
1201 }
1204 }
1206 /*
1207 * Deparse SELECT statement for given relation into buf.
1208 *
1209 * tlist contains the list of desired columns to be fetched from foreign server.
1210 * For a base relation fpinfo->attrs_used is used to construct SELECT clause,
1211 * hence the tlist is ignored for a base relation.
1212 *
1213 * remote_conds is the list of conditions to be deparsed into the WHERE clause
1214 * (or, in the case of upper relations, into the HAVING clause).
1215 *
1216 * If params_list is not NULL, it receives a list of Params and other-relation
1217 * Vars used in the clauses; these values must be transmitted to the remote
1218 * server as parameter values.
1219 *
1220 * If params_list is NULL, we're generating the query for EXPLAIN purposes,
1221 * so Params and other-relation Vars should be replaced by dummy values.
1222 *
1223 * pathkeys is the list of pathkeys to order the result by.
1224 *
1225 * is_subquery is the flag to indicate whether to deparse the specified
1226 * relation as a subquery.
1227 *
1228 * List of columns selected is returned in retrieved_attrs.
1229 */
1230 void
1235 {
1236 deparse_expr_cxt context;
1240 /*
1241 * We handle relations for foreign tables, joins between those and upper
1242 * relations.
1243 */
1246 /* Fill portions of context common to upper, join and base relation */
1253 /* Construct SELECT clause */
1256 /*
1257 * For upper relations, the WHERE clause is built from the remote
1258 * conditions of the underlying scan relation; otherwise, we can use the
1259 * supplied list of remote conditions directly.
1260 */
1262 {
1267 }
1268 else
1271 /* Construct FROM and WHERE clauses */
1275 {
1276 /* Append GROUP BY clause */
1279 /* Append HAVING clause */
1281 {
1284 }
1285 }
1287 /* Add ORDER BY clause if we found any useful pathkeys */
1291 /* Add LIMIT clause if necessary */
1295 /* Add any necessary FOR UPDATE/SHARE. */
1297 }
1299 /*
1300 * Construct a simple SELECT statement that retrieves desired columns
1301 * of the specified foreign table, and append it to "buf". The output
1302 * contains just "SELECT ... ".
1303 *
1304 * We also create an integer List of the columns being retrieved, which is
1305 * returned to *retrieved_attrs, unless we deparse the specified relation
1306 * as a subquery.
1307 *
1308 * tlist is the list of desired columns. is_subquery is the flag to
1309 * indicate whether to deparse the specified relation as a subquery.
1310 * Read prologue of deparseSelectStmtForRel() for details.
1311 */
1312 static void
1315 {
1321 /*
1322 * Construct SELECT list
1323 */
1327 {
1328 /*
1329 * For a relation that is deparsed as a subquery, emit expressions
1330 * specified in the relation's reltarget. Note that since this is for
1331 * the subquery, no need to care about *retrieved_attrs.
1332 */
1334 }
1336 {
1337 /*
1338 * For a join or upper relation the input tlist gives the list of
1339 * columns required to be fetched from the foreign server.
1340 */
1342 }
1343 else
1344 {
1345 /*
1346 * For a base relation fpinfo->attrs_used gives the list of columns
1347 * required to be fetched from the foreign server.
1348 */
1351 /*
1352 * Core code already has some lock on each rel being planned, so we
1353 * can use NoLock here.
1354 */
1360 }
1361 }
1363 /*
1364 * Construct a FROM clause and, if needed, a WHERE clause, and append those to
1365 * "buf".
1366 *
1367 * quals is the list of clauses to be included in the WHERE clause.
1368 * (These may or may not include RestrictInfo decoration.)
1369 */
1370 static void
1372 {
1377 /* For upper relations, scanrel must be either a joinrel or a baserel */
1381 /* Construct FROM clause */
1390 }
1392 /*
1393 * Emit a target list that retrieves the columns specified in attrs_used.
1394 * This is used for both SELECT and RETURNING targetlists; the is_returning
1395 * parameter is true only for a RETURNING targetlist.
1396 *
1397 * The tlist text is appended to buf, and we also create an integer List
1398 * of the columns being retrieved, which is returned to *retrieved_attrs.
1399 *
1400 * If qualify_col is true, add relation alias before the column name.
1401 */
1402 static void
1405 Index rtindex,
1406 Relation rel,
1411 {
1419 /* If there's a whole-row reference, we'll need all the columns. */
1421 attrs_used);
1425 {
1428 /* Ignore dropped attributes. */
1434 attrs_used))
1435 {
1445 }
1446 }
1448 /*
1449 * Add ctid if needed. We currently don't support retrieving any other
1450 * system columns.
1451 */
1453 attrs_used))
1454 {
1466 SelfItemPointerAttributeNumber);
1467 }
1469 /* Don't generate bad syntax if no undropped columns */
1472 }
1474 /*
1475 * Deparse the appropriate locking clause (FOR UPDATE or FOR SHARE) for a
1476 * given relation (context->scanrel).
1477 */
1478 static void
1480 {
1488 {
1489 /*
1490 * Ignore relation if it appears in a lower subquery. Locking clause
1491 * for such a relation is included in the subquery if necessary.
1492 */
1496 /*
1497 * Add FOR UPDATE/SHARE if appropriate. We apply locking during the
1498 * initial row fetch, rather than later on as is done for local
1499 * tables. The extra roundtrips involved in trying to duplicate the
1500 * local semantics exactly don't seem worthwhile (see also comments
1501 * for RowMarkType).
1502 *
1503 * Note: because we actually run the query as a cursor, this assumes
1504 * that DECLARE CURSOR ... FOR UPDATE is supported, which it isn't
1505 * before 8.3.
1506 */
1510 {
1511 /* Relation is UPDATE/DELETE target, so use FOR UPDATE */
1514 /* Add the relation alias if we are here for a join relation */
1517 }
1518 else
1519 {
1523 {
1524 /*
1525 * Relation is specified as a FOR UPDATE/SHARE target, so
1526 * handle that. (But we could also see LCS_NONE, meaning this
1527 * isn't a target relation after all.)
1528 *
1529 * For now, just ignore any [NO] KEY specification, since (a)
1530 * it's not clear what that means for a remote table that we
1531 * don't have complete information about, and (b) it wouldn't
1532 * work anyway on older remote servers. Likewise, we don't
1533 * worry about NOWAIT.
1534 */
1536 {
1538 /* No locking needed */
1548 }
1550 /* Add the relation alias if we are here for a join relation */
1554 }
1555 }
1556 }
1557 }
1559 /*
1560 * Deparse conditions from the provided list and append them to buf.
1561 *
1562 * The conditions in the list are assumed to be ANDed. This function is used to
1563 * deparse WHERE clauses, JOIN .. ON clauses and HAVING clauses.
1564 *
1565 * Depending on the caller, the list elements might be either RestrictInfos
1566 * or bare clauses.
1567 */
1568 static void
1570 {
1576 /* Make sure any constants in the exprs are printed portably */
1580 {
1583 /* Extract clause from RestrictInfo, if required */
1587 /* Connect expressions with "AND" and parenthesize each condition. */
1596 }
1599 }
1601 /*
1602 * Append WHERE clause, containing conditions from exprs and additional_conds,
1603 * to context->buf.
1604 */
1605 static void
1607 {
1615 /*
1616 * If there are some filters, append them.
1617 */
1619 {
1622 }
1624 /*
1625 * If there are some EXISTS conditions, coming from SEMI-JOINS, append
1626 * them.
1627 */
1629 {
1634 }
1635 }
1637 /* Output join name for given join type */
1640 {
1642 {
1659 /* Shouldn't come here, but protect from buggy code. */
1661 }
1663 /* Keep compiler happy */
1665 }
1667 /*
1668 * Deparse given targetlist and append it to context->buf.
1669 *
1670 * tlist is list of TargetEntry's which in turn contain Var nodes.
1671 *
1672 * retrieved_attrs is the list of continuously increasing integers starting
1673 * from 1. It has same number of entries as tlist.
1674 *
1675 * This is used for both SELECT and RETURNING targetlists; the is_returning
1676 * parameter is true only for a RETURNING targetlist.
1677 */
1678 static void
1683 {
1691 {
1702 i++;
1703 }
1707 }
1709 /*
1710 * Emit expressions specified in the given relation's reltarget.
1711 *
1712 * This is used for deparsing the given relation as a subquery.
1713 */
1714 static void
1716 {
1722 /* Should only be called in these cases. */
1727 {
1735 }
1737 /* Don't generate bad syntax if no expressions */
1740 }
1742 /*
1743 * Construct FROM clause for given relation
1744 *
1745 * The function constructs ... JOIN ... ON ... for join relation. For a base
1746 * relation it just returns schema-qualified tablename, with the appropriate
1747 * alias if so requested.
1748 *
1749 * 'ignore_rel' is either zero or the RT index of a target relation. In the
1750 * latter case the function constructs FROM clause of UPDATE or USING clause
1751 * of DELETE; it deparses the join relation as if the relation never contained
1752 * the target relation, and creates a List of conditions to be deparsed into
1753 * the top-level WHERE clause, which is returned to *ignore_conds.
1754 *
1755 * 'additional_conds' is a pointer to a list of strings to be appended to
1756 * the WHERE clause, coming from lower-level SEMI-JOINs.
1757 */
1758 static void
1762 {
1766 {
1767 StringInfoData join_sql_o;
1768 StringInfoData join_sql_i;
1777 {
1778 /*
1779 * If this is an inner join, add joinclauses to *ignore_conds and
1780 * set it to empty so that those can be deparsed into the WHERE
1781 * clause. Note that since the target relation can never be
1782 * within the nullable side of an outer join, those could safely
1783 * be pulled up into the WHERE clause (see foreign_join_ok()).
1784 * Note also that since the target relation is only inner-joined
1785 * to any other relation in the query, all conditions in the join
1786 * tree mentioning the target relation could be deparsed into the
1787 * WHERE clause by doing this recursively.
1788 */
1790 {
1794 }
1796 /*
1797 * Check if either of the input relations is the target relation.
1798 */
1803 }
1805 /* Deparse outer relation if not the target relation. */
1807 {
1812 params_list);
1814 /*
1815 * If inner relation is the target relation, skip deparsing it.
1816 * Note that since the join of the target relation with any other
1817 * relation in the query is an inner join and can never be within
1818 * the nullable side of an outer join, the join could be
1819 * interchanged with higher-level joins (cf. identity 1 on outer
1820 * join reordering shown in src/backend/optimizer/README), which
1821 * means it's safe to skip the target-relation deparsing here.
1822 */
1824 {
1828 /* Pass EXISTS conditions to upper level */
1830 {
1833 }
1835 }
1836 }
1838 /* Deparse inner relation if not the target relation. */
1840 {
1845 params_list);
1847 /*
1848 * SEMI-JOIN is deparsed as the EXISTS subquery. It references
1849 * outer and inner relations, so it should be evaluated as the
1850 * condition in the upper-level WHERE clause. We deparse the
1851 * condition and pass it to upper level callers as an
1852 * additional_conds list. Upper level callers are responsible for
1853 * inserting conditions from the list where appropriate.
1854 */
1856 {
1857 deparse_expr_cxt context;
1858 StringInfoData str;
1860 /* Construct deparsed condition from this SEMI-JOIN */
1871 /*
1872 * Append SEMI-JOIN clauses and EXISTS conditions from lower
1873 * levels to the current EXISTS subquery
1874 */
1877 /*
1878 * EXISTS conditions, coming from lower join levels, have just
1879 * been processed.
1880 */
1882 {
1885 }
1887 /* Close parentheses for EXISTS subquery */
1891 }
1893 /*
1894 * If outer relation is the target relation, skip deparsing it.
1895 * See the above note about safety.
1896 */
1898 {
1902 /* Pass EXISTS conditions to the upper call */
1904 {
1907 }
1909 }
1910 }
1912 /* Neither of the relations is the target relation. */
1915 /*
1916 * For semijoin FROM clause is deparsed as an outer relation. An inner
1917 * relation and join clauses are converted to EXISTS condition and
1918 * passed to the upper level.
1919 */
1921 {
1923 }
1924 else
1925 {
1926 /*
1927 * For a join relation FROM clause, entry is deparsed as
1928 *
1929 * ((outer relation) <join type> (inner relation) ON
1930 * (joinclauses))
1931 */
1935 /* Append join clause; (TRUE) if no join clause */
1937 {
1938 deparse_expr_cxt context;
1949 }
1950 else
1953 /* End the FROM clause entry. */
1955 }
1957 /*
1958 * Construct additional_conds to be passed to the upper caller from
1959 * current level additional_conds and additional_conds, coming from
1960 * inner and outer rels.
1961 */
1963 {
1965 additional_conds_o);
1967 }
1970 {
1972 additional_conds_i);
1974 }
1975 }
1976 else
1977 {
1980 /*
1981 * Core code already has some lock on each rel being planned, so we
1982 * can use NoLock here.
1983 */
1988 /*
1989 * Add a unique alias to avoid any conflict in relation names due to
1990 * pulled up subqueries in the query being built for a pushed down
1991 * join.
1992 */
1997 }
1998 }
2000 /*
2001 * Append FROM clause entry for the given relation into buf.
2002 * Conditions from lower-level SEMI-JOINs are appended to additional_conds
2003 * and should be added to upper level WHERE clause.
2004 */
2005 static void
2009 {
2012 /* Should only be called in these cases. */
2017 /* If make_subquery is true, deparse the relation as a subquery. */
2019 {
2023 /*
2024 * The given relation shouldn't contain the target relation, because
2025 * this should only happen for input relations for a full join, and
2026 * such relations can never contain an UPDATE/DELETE target.
2027 */
2031 /* Deparse the subquery representing the relation. */
2039 /* Append the relation alias. */
2043 /*
2044 * Append the column aliases if needed. Note that the subquery emits
2045 * expressions specified in the relation's reltarget (see
2046 * deparseSubqueryTargetList).
2047 */
2050 {
2055 {
2060 }
2062 }
2063 }
2064 else
2067 params_list);
2068 }
2070 /*
2071 * deparse remote INSERT statement
2072 *
2073 * The statement text is appended to buf, and we also create an integer List
2074 * of the columns being retrieved by WITH CHECK OPTION or RETURNING (if any),
2075 * which is returned to *retrieved_attrs.
2076 *
2077 * This also stores end position of the VALUES clause, so that we can rebuild
2078 * an INSERT for a batch of rows later.
2079 */
2080 void
2086 {
2088 AttrNumber pindex;
2096 {
2101 {
2109 }
2116 {
2126 else
2127 {
2129 pindex++;
2130 }
2131 }
2134 }
2135 else
2145 }
2147 /*
2148 * rebuild remote INSERT statement
2149 *
2150 * Provided a number of rows in a batch, builds INSERT statement with the
2151 * right number of parameters.
2152 */
2153 void
2158 {
2165 /* Make sure the values_end_len is sensible */
2168 /* Copy up to the end of the first record from the original query */
2171 /*
2172 * Add records to VALUES clause (we already have parameters for the first
2173 * row, so start at the right offset).
2174 */
2177 {
2182 {
2192 else
2193 {
2195 pindex++;
2196 }
2197 }
2200 }
2202 /* Copy stuff after VALUES clause from the original query */
2204 }
2206 /*
2207 * deparse remote UPDATE statement
2208 *
2209 * The statement text is appended to buf, and we also create an integer List
2210 * of the columns being retrieved by WITH CHECK OPTION or RETURNING (if any),
2211 * which is returned to *retrieved_attrs.
2212 */
2213 void
2219 {
2221 AttrNumber pindex;
2232 {
2243 else
2244 {
2246 pindex++;
2247 }
2248 }
2254 }
2256 /*
2257 * deparse remote UPDATE statement
2258 *
2259 * 'buf' is the output buffer to append the statement to
2260 * 'rtindex' is the RT index of the associated target relation
2261 * 'rel' is the relation descriptor for the target relation
2262 * 'foreignrel' is the RelOptInfo for the target relation or the join relation
2263 * containing all base relations in the query
2264 * 'targetlist' is the tlist of the underlying foreign-scan plan node
2265 * (note that this only contains new-value expressions and junk attrs)
2266 * 'targetAttrs' is the target columns of the UPDATE
2267 * 'remote_conds' is the qual clauses that must be evaluated remotely
2268 * '*params_list' is an output list of exprs that will become remote Params
2269 * 'returningList' is the RETURNING targetlist
2270 * '*retrieved_attrs' is an output list of integers of columns being retrieved
2271 * by RETURNING (if any)
2272 */
2273 void
2283 {
2284 deparse_expr_cxt context;
2292 /* Set up context struct for recursion */
2305 /* Make sure any constants in the exprs are printed portably */
2310 {
2314 /* update's new-value expressions shouldn't be resjunk */
2324 }
2329 {
2337 }
2347 else
2350 }
2352 /*
2353 * deparse remote DELETE statement
2354 *
2355 * The statement text is appended to buf, and we also create an integer List
2356 * of the columns being retrieved by RETURNING (if any), which is returned
2357 * to *retrieved_attrs.
2358 */
2359 void
2364 {
2372 }
2374 /*
2375 * deparse remote DELETE statement
2376 *
2377 * 'buf' is the output buffer to append the statement to
2378 * 'rtindex' is the RT index of the associated target relation
2379 * 'rel' is the relation descriptor for the target relation
2380 * 'foreignrel' is the RelOptInfo for the target relation or the join relation
2381 * containing all base relations in the query
2382 * 'remote_conds' is the qual clauses that must be evaluated remotely
2383 * '*params_list' is an output list of exprs that will become remote Params
2384 * 'returningList' is the RETURNING targetlist
2385 * '*retrieved_attrs' is an output list of integers of columns being retrieved
2386 * by RETURNING (if any)
2387 */
2388 void
2396 {
2397 deparse_expr_cxt context;
2400 /* Set up context struct for recursion */
2413 {
2420 }
2430 else
2434 }
2436 /*
2437 * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
2438 */
2439 static void
2446 {
2450 {
2451 /* whole-row reference acquires all non-system columns */
2452 attrs_used =
2454 }
2457 {
2458 /*
2459 * We need the attrs, non-system and system, mentioned in the local
2460 * query's WITH CHECK OPTION list.
2461 *
2462 * Note: we do this to ensure that WCO constraints will be evaluated
2463 * on the data actually inserted/updated on the remote side, which
2464 * might differ from the data supplied by the core code, for example
2465 * as a result of remote triggers.
2466 */
2469 }
2472 {
2473 /*
2474 * We need the attrs, non-system and system, mentioned in the local
2475 * query's RETURNING list.
2476 */
2479 }
2483 retrieved_attrs);
2484 else
2486 }
2488 /*
2489 * Construct SELECT statement to acquire size in blocks of given relation.
2490 *
2491 * Note: we use local definition of block size, not remote definition.
2492 * This is perhaps debatable.
2493 *
2494 * Note: pg_relation_size() exists in 8.1 and later.
2495 */
2496 void
2498 {
2499 StringInfoData relname;
2501 /* We'll need the remote relation name as a literal. */
2508 }
2510 /*
2511 * Construct SELECT statement to acquire the number of rows and the relkind of
2512 * a relation.
2513 *
2514 * Note: we just return the remote server's reltuples value, which might
2515 * be off a good deal, but it doesn't seem worth working harder. See
2516 * comments in postgresAcquireSampleRowsFunc.
2517 */
2518 void
2520 {
2521 StringInfoData relname;
2523 /* We'll need the remote relation name as a literal. */
2527 appendStringInfoString(buf, "SELECT reltuples, relkind FROM pg_catalog.pg_class WHERE oid = ");
2530 }
2532 /*
2533 * Construct SELECT statement to acquire sample rows of given relation.
2534 *
2535 * SELECT command is appended to buf, and list of columns retrieved
2536 * is returned to *retrieved_attrs.
2537 *
2538 * We only support sampling methods we can decide based on server version.
2539 * Allowing custom TSM modules (like tsm_system_rows) might be useful, but it
2540 * would require detecting which extensions are installed, to allow automatic
2541 * fall-back. Moreover, the methods may use different parameters like number
2542 * of rows (and not sampling rate). So we leave this for future improvements.
2543 *
2544 * Using random() to sample rows on the remote server has the advantage that
2545 * this works on all PostgreSQL versions (unlike TABLESAMPLE), and that it
2546 * does the sampling on the remote side (without transferring everything and
2547 * then discarding most rows).
2548 *
2549 * The disadvantage is that we still have to read all rows and evaluate the
2550 * random(), while TABLESAMPLE (at least with the "system" method) may skip.
2551 * It's not that different from the "bernoulli" method, though.
2552 *
2553 * We could also do "ORDER BY random() LIMIT x", which would always pick
2554 * the expected number of rows, but it requires sorting so it may be much
2555 * more expensive (particularly on large tables, which is what the
2556 * remote sampling is meant to improve).
2557 */
2558 void
2562 {
2575 {
2576 /* Ignore dropped columns. */
2584 /* Use attribute name or column_name option. */
2589 {
2593 {
2596 }
2597 }
2602 }
2604 /* Don't generate bad syntax for zero-column relation. */
2608 /*
2609 * Construct FROM clause, and perhaps WHERE clause too, depending on the
2610 * selected sampling method.
2611 */
2616 {
2618 /* nothing to do here */
2634 /* should have been resolved into actual method */
2637 }
2638 }
2640 /*
2641 * Construct a simple "TRUNCATE rel" statement
2642 */
2643 void
2646 DropBehavior behavior,
2648 {
2654 {
2661 }
2670 }
2672 /*
2673 * Construct name to use for given column, and emit it into buf.
2674 * If it has a column_name FDW option, use that instead of attribute name.
2675 *
2676 * If qualify_col is true, qualify column name with the alias of relation.
2677 */
2678 static void
2681 {
2682 /* We support fetching the remote side's CTID and OID. */
2684 {
2688 }
2690 {
2691 /*
2692 * All other system attributes are fetched as 0, except for table OID,
2693 * which is fetched as the local table OID. However, we must be
2694 * careful; the table could be beneath an outer join, in which case it
2695 * must go to NULL whenever the rest of the row does.
2696 */
2703 {
2707 }
2708 else
2710 }
2712 {
2713 /* Whole row reference */
2714 Relation rel;
2717 /* Required only to be passed down to deparseTargetList(). */
2720 /*
2721 * The lock on the relation will be held by upper callers, so it's
2722 * fine to open it with no lock here.
2723 */
2726 /*
2727 * The local name of the foreign table can not be recognized by the
2728 * foreign server and the table it references on foreign server might
2729 * have different column ordering or different columns than those
2730 * declared locally. Hence we have to deparse whole-row reference as
2731 * ROW(columns referenced locally). Construct this by deparsing a
2732 * "whole row" attribute.
2733 */
2737 /*
2738 * In case the whole-row reference is under an outer join then it has
2739 * to go NULL whenever the rest of the row goes NULL. Deparsing a join
2740 * query would always involve multiple relations, thus qualify_col
2741 * would be true.
2742 */
2744 {
2748 }
2755 /* Complete the CASE WHEN statement started above. */
2761 }
2762 else
2763 {
2768 /* varno must not be any of OUTER_VAR, INNER_VAR and INDEX_VAR. */
2771 /*
2772 * If it's a column of a foreign table, and it has the column_name FDW
2773 * option, use that value.
2774 */
2777 {
2781 {
2784 }
2785 }
2787 /*
2788 * If it's a column of a regular table or it doesn't have column_name
2789 * FDW option, use attribute name.
2790 */
2798 }
2799 }
2801 /*
2802 * Append remote name of specified foreign table to buf.
2803 * Use value of table_name FDW option (if any) instead of relation's name.
2804 * Similarly, schema_name FDW option overrides schema name.
2805 */
2806 static void
2808 {
2814 /* obtain additional catalog information. */
2817 /*
2818 * Use value of FDW options if any, instead of the name of object itself.
2819 */
2821 {
2828 }
2830 /*
2831 * Note: we could skip printing the schema name if it's pg_catalog, but
2832 * that doesn't seem worth the trouble.
2833 */
2841 }
2843 /*
2844 * Append a SQL string literal representing "val" to buf.
2845 */
2846 void
2848 {
2851 /*
2852 * Rather than making assumptions about the remote server's value of
2853 * standard_conforming_strings, always use E'foo' syntax if there are any
2854 * backslashes. This will fail on remote servers before 8.1, but those
2855 * are long out of support.
2856 */
2861 {
2867 }
2869 }
2871 /*
2872 * Deparse given expression into context->buf.
2873 *
2874 * This function must support all the same node types that foreign_expr_walker
2875 * accepts.
2876 *
2877 * Note: unlike ruleutils.c, we just use a simple hard-wired parenthesization
2878 * scheme: anything more complex than a Var, Const, function call or cast
2879 * should be self-parenthesized.
2880 */
2881 static void
2883 {
2888 {
2935 }
2936 }
2938 /*
2939 * Deparse given Var node into context->buf.
2940 *
2941 * If the Var belongs to the foreign relation, just print its remote name.
2942 * Otherwise, it's effectively a Param (and will in fact be a Param at
2943 * run time). Handle it the same way we handle plain Params --- see
2944 * deparseParam for comments.
2945 */
2946 static void
2948 {
2953 /* Qualify columns when multiple relations are involved. */
2956 /*
2957 * If the Var belongs to the foreign relation that is deparsed as a
2958 * subquery, use the relation and column alias to the Var provided by the
2959 * subquery, instead of the remote name.
2960 */
2962 {
2967 }
2972 qualify_col);
2973 else
2974 {
2975 /* Treat like a Param */
2977 {
2981 /* find its index in params_list */
2983 {
2984 pindex++;
2987 }
2989 {
2990 /* not in list, so add it */
2991 pindex++;
2993 }
2996 }
2997 else
2998 {
3000 }
3001 }
3002 }
3004 /*
3005 * Deparse given constant value into context->buf.
3006 *
3007 * This function has to be kept in sync with ruleutils.c's get_const_expr.
3008 *
3009 * As in that function, showtype can be -1 to never show "::typename"
3010 * decoration, +1 to always show it, or 0 to show it only if the constant
3011 * wouldn't be assumed to be the right type by default.
3012 *
3013 * In addition, this code allows showtype to be -2 to indicate that we should
3014 * not show "::typename" decoration if the constant is printed as an untyped
3015 * literal or NULL (while in other cases, behaving as for showtype == 0).
3016 */
3017 static void
3019 {
3021 Oid typoutput;
3029 {
3036 }
3043 {
3051 {
3052 /*
3053 * No need to quote unless it's a special value such as 'NaN'.
3054 * See comments in get_const_expr().
3055 */
3057 {
3060 else
3064 }
3065 else
3067 }
3076 else
3083 }
3090 /*
3091 * For showtype == 0, append ::typename unless the constant will be
3092 * implicitly typed as the right type when it is read in.
3093 *
3094 * XXX this code has to be kept in sync with the behavior of the parser,
3095 * especially make_const.
3096 */
3098 {
3109 {
3110 /* label unless we printed it as an untyped string */
3112 }
3113 else
3116 }
3121 }
3123 /*
3124 * Deparse given Param node.
3125 *
3126 * If we're generating the query "for real", add the Param to
3127 * context->params_list if it's not already present, and then use its index
3128 * in that list as the remote parameter number. During EXPLAIN, there's
3129 * no need to identify a parameter number.
3130 */
3131 static void
3133 {
3135 {
3139 /* find its index in params_list */
3141 {
3142 pindex++;
3145 }
3147 {
3148 /* not in list, so add it */
3149 pindex++;
3151 }
3154 }
3155 else
3156 {
3158 }
3159 }
3161 /*
3162 * Deparse a container subscript expression.
3163 */
3164 static void
3166 {
3171 /* Always parenthesize the expression. */
3174 /*
3175 * Deparse referenced array expression first. If that expression includes
3176 * a cast, we have to parenthesize to prevent the array subscript from
3177 * being taken as typename decoration. We can avoid that in the typical
3178 * case of subscripting a Var, but otherwise do it.
3179 */
3182 else
3183 {
3187 }
3189 /* Deparse subscript expressions. */
3192 {
3195 {
3199 }
3202 }
3205 }
3207 /*
3208 * Deparse a function call.
3209 */
3210 static void
3212 {
3218 /*
3219 * If the function call came from an implicit coercion, then just show the
3220 * first argument.
3221 */
3223 {
3226 }
3228 /*
3229 * If the function call came from a cast, then show the first argument
3230 * plus an explicit cast operation.
3231 */
3233 {
3235 int32 coercedTypmod;
3237 /* Get the typmod if this is a length-coercion function */
3244 }
3246 /* Check if need to print VARIADIC (cf. ruleutils.c) */
3249 /*
3250 * Normal function: display as proname(args).
3251 */
3255 /* ... and all the arguments */
3258 {
3265 }
3267 }
3269 /*
3270 * Deparse given operator expression. To avoid problems around
3271 * priority of operations, we always parenthesize the arguments.
3272 */
3273 static void
3275 {
3277 HeapTuple tuple;
3278 Form_pg_operator form;
3283 /* Retrieve information about the operator from system catalog. */
3290 /* Sanity check. */
3296 /* Always parenthesize the expression. */
3299 /* Deparse left operand, if any. */
3301 {
3307 /*
3308 * When considering a binary operator, if one operand is a Const that
3309 * can be printed as a bare string literal or NULL (i.e., it will look
3310 * like type UNKNOWN to the remote parser), the Const normally
3311 * receives an explicit cast to the operator's input type. However,
3312 * in Const-to-Var comparisons where both operands are of the same
3313 * type, we prefer to suppress the explicit cast, leaving the Const's
3314 * type resolution up to the remote parser. The remote's resolution
3315 * heuristic will assume that an unknown input type being compared to
3316 * a known input type is of that known type as well.
3317 *
3318 * This hack allows some cases to succeed where a remote column is
3319 * declared with a different type in the local (foreign) table. By
3320 * emitting "foreigncol = 'foo'" not "foreigncol = 'foo'::text" or the
3321 * like, we allow the remote parser to pick an "=" operator that's
3322 * compatible with whatever type the remote column really is, such as
3323 * an enum.
3324 *
3325 * We allow cast suppression to happen only when the other operand is
3326 * a plain foreign Var. Although the remote's unknown-type heuristic
3327 * would apply to other cases just as well, we would be taking a
3328 * bigger risk that the inferred type is something unexpected. With
3329 * this restriction, if anything goes wrong it's the user's fault for
3330 * not declaring the local column with the same type as the remote
3331 * column.
3332 */
3334 {
3339 }
3343 else
3347 }
3349 /* Deparse operator name. */
3352 /* Deparse right operand. */
3357 else
3363 }
3365 /*
3366 * Will "node" deparse as a plain foreign Var?
3367 */
3368 static bool
3370 {
3371 /*
3372 * We allow the foreign Var to have an implicit RelabelType, mainly so
3373 * that this'll work with varchar columns. Note that deparseRelabelType
3374 * will not print such a cast, so we're not breaking the restriction that
3375 * the expression print as a plain Var. We won't risk it for an implicit
3376 * cast that requires a function, nor for non-implicit RelabelType; such
3377 * cases seem too likely to involve semantics changes compared to what
3378 * would happen on the remote side.
3379 */
3385 {
3386 /*
3387 * The Var must be one that'll deparse as a foreign column reference
3388 * (cf. deparseVar).
3389 */
3395 }
3398 }
3400 /*
3401 * Print the name of an operator.
3402 */
3403 static void
3405 {
3408 /* opname is not a SQL identifier, so we should not quote it. */
3411 /* Print schema name only if it's not pg_catalog */
3413 {
3417 /* Print fully qualified operator name. */
3420 }
3421 else
3422 {
3423 /* Just print operator name. */
3425 }
3426 }
3428 /*
3429 * Deparse IS DISTINCT FROM.
3430 */
3431 static void
3433 {
3443 }
3445 /*
3446 * Deparse given ScalarArrayOpExpr expression. To avoid problems
3447 * around priority of operations, we always parenthesize the arguments.
3448 */
3449 static void
3451 {
3453 HeapTuple tuple;
3454 Form_pg_operator form;
3458 /* Retrieve information about the operator from system catalog. */
3464 /* Sanity check. */
3467 /* Always parenthesize the expression. */
3470 /* Deparse left operand. */
3475 /* Deparse operator name plus decoration. */
3479 /* Deparse right operand. */
3485 /* Always parenthesize the expression. */
3489 }
3491 /*
3492 * Deparse a RelabelType (binary-compatible cast) node.
3493 */
3494 static void
3496 {
3502 }
3504 /*
3505 * Deparse a BoolExpr node.
3506 */
3507 static void
3509 {
3516 {
3528 }
3533 {
3538 }
3540 }
3542 /*
3543 * Deparse IS [NOT] NULL expression.
3544 */
3545 static void
3547 {
3553 /*
3554 * For scalar inputs, we prefer to print as IS [NOT] NULL, which is
3555 * shorter and traditional. If it's a rowtype input but we're applying a
3556 * scalar test, must print IS [NOT] DISTINCT FROM NULL to be semantically
3557 * correct.
3558 */
3560 {
3563 else
3565 }
3566 else
3567 {
3570 else
3572 }
3573 }
3575 /*
3576 * Deparse CASE expression
3577 */
3578 static void
3580 {
3586 /* If this is a CASE arg WHEN then emit the arg expression */
3588 {
3591 }
3593 /* Add each condition/result of the CASE clause */
3595 {
3598 /* WHEN */
3603 {
3604 /* Ignore the CaseTestExpr and equality operator. */
3606 context);
3607 }
3609 /* THEN */
3612 }
3614 /* add ELSE if present */
3616 {
3619 }
3621 /* append END */
3623 }
3625 /*
3626 * Deparse ARRAY[...] construct.
3627 */
3628 static void
3630 {
3637 {
3642 }
3645 /* If the array is empty, we need an explicit cast to the array type. */
3649 }
3651 /*
3652 * Deparse an Aggref node.
3653 */
3654 static void
3656 {
3660 /* Only basic, non-split aggregation accepted. */
3663 /* Check if need to print VARIADIC (cf. ruleutils.c) */
3666 /* Find aggregate name from aggfnoid which is a pg_proc entry */
3670 /* Add DISTINCT */
3674 {
3675 /* Add WITHIN GROUP (ORDER BY ..) */
3683 {
3689 }
3693 }
3694 else
3695 {
3696 /* aggstar can be set only in zero-argument aggregates */
3699 else
3700 {
3704 /* Add all the arguments */
3706 {
3717 /* Add VARIADIC */
3722 }
3723 }
3725 /* Add ORDER BY */
3727 {
3730 }
3731 }
3733 /* Add FILTER (WHERE ..) */
3735 {
3738 }
3741 }
3743 /*
3744 * Append ORDER BY within aggregate function.
3745 */
3746 static void
3748 {
3754 {
3762 /* Deparse the sort expression proper. */
3765 /* Add decoration as needed. */
3767 context);
3768 }
3769 }
3771 /*
3772 * Append the ASC, DESC, USING <OPERATOR> and NULLS FIRST / NULLS LAST parts
3773 * of an ORDER BY clause.
3774 */
3775 static void
3778 {
3782 /* See whether operator is default < or > for sort expr's datatype. */
3790 else
3791 {
3792 HeapTuple opertup;
3793 Form_pg_operator operform;
3797 /* Append operator name. */
3804 }
3808 else
3810 }
3812 /*
3813 * Print the representation of a parameter to be sent to the remote side.
3814 *
3815 * Note: we always label the Param's type explicitly rather than relying on
3816 * transmitting a numeric type OID in PQsendQueryParams(). This allows us to
3817 * avoid assuming that types have the same OIDs on the remote side as they
3818 * do locally --- they need only have the same names.
3819 */
3820 static void
3823 {
3828 }
3830 /*
3831 * Print the representation of a placeholder for a parameter that will be
3832 * sent to the remote side at execution time.
3833 *
3834 * This is used when we're just trying to EXPLAIN the remote query.
3835 * We don't have the actual value of the runtime parameter yet, and we don't
3836 * want the remote planner to generate a plan that depends on such a value
3837 * anyway. Thus, we can't do something simple like "$1::paramtype".
3838 * Instead, we emit "((SELECT null::paramtype)::paramtype)".
3839 * In all extant versions of Postgres, the planner will see that as an unknown
3840 * constant value, which is what we want. This might need adjustment if we
3841 * ever make the planner flatten scalar subqueries. Note: the reason for the
3842 * apparently useless outer cast is to ensure that the representation as a
3843 * whole will be parsed as an a_expr and not a select_with_parens; the latter
3844 * would do the wrong thing in the context "x = ANY(...)".
3845 */
3846 static void
3849 {
3854 }
3856 /*
3857 * Deparse GROUP BY clause.
3858 */
3859 static void
3861 {
3867 /* Nothing to be done, if there's no GROUP BY clause in the query. */
3873 /*
3874 * Queries with grouping sets are not pushed down, so we don't expect
3875 * grouping sets here.
3876 */
3879 /*
3880 * We intentionally print query->groupClause not processed_groupClause,
3881 * leaving it to the remote planner to get rid of any redundant GROUP BY
3882 * items again. This is necessary in case processed_groupClause reduced
3883 * to empty, and in any case the redundancy situation on the remote might
3884 * be different than what we think here.
3885 */
3887 {
3895 }
3896 }
3898 /*
3899 * Deparse ORDER BY clause defined by the given pathkeys.
3900 *
3901 * The clause should use Vars from context->scanrel if !has_final_sort,
3902 * or from context->foreignrel's targetlist if has_final_sort.
3903 *
3904 * We find a suitable pathkey expression (some earlier step
3905 * should have verified that there is one) and deparse it.
3906 */
3907 static void
3910 {
3916 /* Make sure any constants in the exprs are printed portably */
3920 {
3924 Oid oprid;
3927 {
3928 /*
3929 * By construction, context->foreignrel is the input relation to
3930 * the final sort.
3931 */
3935 }
3936 else
3941 /*
3942 * We don't expect any error here; it would mean that shippability
3943 * wasn't verified earlier. For the same reason, we don't recheck
3944 * shippability of the sort operator.
3945 */
3951 /*
3952 * If the member is a Const expression then we needn't add it to the
3953 * ORDER BY clause. This can happen in UNION ALL queries where the
3954 * union child targetlist has a Const. Adding these would be
3955 * wasteful, but also, for INT columns, an integer literal would be
3956 * seen as an ordinal column position rather than a value to sort by.
3957 * deparseConst() does have code to handle this, but it seems less
3958 * effort on all accounts just to skip these for ORDER BY clauses.
3959 */
3964 {
3967 }
3968 else
3971 /*
3972 * Lookup the operator corresponding to the strategy in the opclass.
3973 * The datatype used by the opfamily is not necessarily the same as
3974 * the expression type (for array types for example).
3975 */
3987 /*
3988 * Here we need to use the expression's actual type to discover
3989 * whether the desired operator will be the default or not.
3990 */
3994 }
3996 }
3998 /*
3999 * Deparse LIMIT/OFFSET clause.
4000 */
4001 static void
4003 {
4008 /* Make sure any constants in the exprs are printed portably */
4012 {
4015 }
4017 {
4020 }
4023 }
4025 /*
4026 * appendFunctionName
4027 * Deparses function name from given function oid.
4028 */
4029 static void
4031 {
4033 HeapTuple proctup;
4034 Form_pg_proc procform;
4042 /* Print schema name only if it's not pg_catalog */
4044 {
4049 }
4051 /* Always print the function name */
4056 }
4058 /*
4059 * Appends a sort or group clause.
4060 *
4061 * Like get_rule_sortgroupclause(), returns the expression tree, so caller
4062 * need not find it again.
4063 */
4067 {
4076 {
4077 /* Use column-number form when requested by caller. */
4080 }
4082 {
4083 /*
4084 * Force a typecast here so that we don't emit something like "GROUP
4085 * BY 2", which will be misconstrued as a column position rather than
4086 * a constant.
4087 */
4089 }
4092 else
4093 {
4094 /* Always parenthesize the expression. */
4098 }
4101 }
4104 /*
4105 * Returns true if given Var is deparsed as a subquery output column, in
4106 * which case, *relno and *colno are set to the IDs for the relation and
4107 * column alias to the Var provided by the subquery.
4108 */
4109 static bool
4111 {
4116 /* Should only be called in these cases. */
4119 /*
4120 * If the given relation isn't a join relation, it doesn't have any lower
4121 * subqueries, so the Var isn't a subquery output column.
4122 */
4126 /*
4127 * If the Var doesn't belong to any lower subqueries, it isn't a subquery
4128 * output column.
4129 */
4134 {
4135 /*
4136 * If outer relation is deparsed as a subquery, the Var is an output
4137 * column of the subquery; get the IDs for the relation/column alias.
4138 */
4140 {
4143 }
4145 /* Otherwise, recurse into the outer relation. */
4147 }
4148 else
4149 {
4152 /*
4153 * If inner relation is deparsed as a subquery, the Var is an output
4154 * column of the subquery; get the IDs for the relation/column alias.
4155 */
4157 {
4160 }
4162 /* Otherwise, recurse into the inner relation. */
4164 }
4165 }
4167 /*
4168 * Get the IDs for the relation and column alias to given Var belonging to
4169 * given relation, which are returned into *relno and *colno.
4170 */
4171 static void
4174 {
4179 /* Get the relation alias ID */
4182 /* Get the column alias ID */
4185 {
4188 /*
4189 * Match reltarget entries only on varno/varattno. Ideally there
4190 * would be some cross-check on varnullingrels, but it's unclear what
4191 * to do exactly; we don't have enough context to know what that value
4192 * should be.
4193 */
4197 {
4200 }
4201 i++;
4202 }
4204 /* Shouldn't get here */
4206 }