| blob | 09d6dd60ddc87f1070c7568cedfe88f7a36a1ecd |
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-2023, PostgreSQL Global Development Group
28 *
29 * IDENTIFICATION
30 * contrib/postgres_fdw/deparse.c
31 *
32 *-------------------------------------------------------------------------
33 */
65 /*
66 * Global context for foreign_expr_walker's search of an expression tree.
67 */
69 {
73 * scan */
76 /*
77 * Local (per-tree-level) context for foreign_expr_walker's search.
78 * This is concerned with identifying collations used in the expression.
79 */
81 {
83 * it has default collation that is not
84 * traceable to a foreign Var */
86 FDW_COLLATE_UNSAFE /* collation is non-default and derives from
87 * something other than a foreign Var */
91 {
96 /*
97 * Context for deparseExpr
98 */
100 {
104 * foreignrel, when that represents a join or
105 * a base relation. */
111 /* Handy macro to add relation name qualification */
112 #define ADD_REL_QUALIFIER(buf, varno) \
117 /*
118 * Functions to determine whether an expression can be evaluated safely on
119 * remote server.
120 */
127 /*
128 * Functions to construct string representation of a node tree.
129 */
132 Index rtindex,
133 Relation rel,
198 /*
199 * Helper functions
200 */
207 /*
208 * Examine each qual clause in input_conds, and classify them into two groups,
209 * which are returned as two lists:
210 * - remote_conds contains expressions that can be evaluated remotely
211 * - local_conds contains expressions that can't be evaluated remotely
212 */
213 void
219 {
226 {
231 else
233 }
234 }
236 /*
237 * Returns true if given expr is safe to evaluate on the foreign server.
238 */
239 bool
243 {
244 foreign_glob_cxt glob_cxt;
245 foreign_loc_cxt loc_cxt;
248 /*
249 * Check that the expression consists of nodes that are safe to execute
250 * remotely.
251 */
255 /*
256 * For an upper relation, use relids from its underneath scan relation,
257 * because the upperrel's own relids currently aren't set to anything
258 * meaningful by the core code. For other relation, use their own relids.
259 */
262 else
269 /*
270 * If the expression has a valid collation that does not arise from a
271 * foreign var, the expression can not be sent over.
272 */
276 /*
277 * An expression which includes any mutable functions can't be sent over
278 * because its result is not stable. For example, sending now() remote
279 * side could cause confusion from clock offsets. Future versions might
280 * be able to make this choice with more granularity. (We check this last
281 * because it requires a lot of expensive catalog lookups.)
282 */
286 /* OK to evaluate on the remote server */
288 }
290 /*
291 * Check if expression is safe to execute remotely, and return true if so.
292 *
293 * In addition, *outer_cxt is updated with collation information.
294 *
295 * case_arg_cxt is NULL if this subexpression is not inside a CASE-with-arg.
296 * Otherwise, it points to the collation info derived from the arg expression,
297 * which must be consulted by any CaseTestExpr.
298 *
299 * We must check that the expression contains only node types we can deparse,
300 * that all types/functions/operators are safe to send (they are "shippable"),
301 * and that all collations used in the expression derive from Vars of the
302 * foreign table. Because of the latter, the logic is pretty close to
303 * assign_collations_walker() in parse_collate.c, though we can assume here
304 * that the given expression is valid. Note function mutability is not
305 * currently considered here.
306 */
307 static bool
312 {
315 foreign_loc_cxt inner_cxt;
316 Oid collation;
317 FDWCollateState state;
319 /* Need do nothing for empty subexpressions */
323 /* May need server info from baserel's fdw_private struct */
326 /* Set up inner_cxt for possible recursion to child nodes */
331 {
333 {
336 /*
337 * If the Var is from the foreign table, we consider its
338 * collation (if any) safe to use. If it is from another
339 * table, we treat its collation the same way as we would a
340 * Param's collation, ie it's not safe for it to have a
341 * non-default collation.
342 */
345 {
346 /* Var belongs to foreign table */
348 /*
349 * System columns other than ctid should not be sent to
350 * the remote, since we don't make any effort to ensure
351 * that local and remote values match (tableoid, in
352 * particular, almost certainly doesn't match).
353 */
358 /* Else check the collation */
361 }
362 else
363 {
364 /* Var belongs to some other table */
368 {
369 /*
370 * It's noncollatable, or it's safe to combine with a
371 * collatable foreign Var, so set state to NONE.
372 */
374 }
375 else
376 {
377 /*
378 * Do not fail right away, since the Var might appear
379 * in a collation-insensitive context.
380 */
382 }
383 }
384 }
387 {
390 /*
391 * Constants of regproc and related types can't be shipped
392 * unless the referenced object is shippable. But NULL's ok.
393 * (See also the related code in dependency.c.)
394 */
396 {
398 {
428 /*
429 * For text search objects only, we weaken the
430 * normal shippability criterion to allow all OIDs
431 * below FirstNormalObjectId. Without this, none
432 * of the initdb-installed TS configurations would
433 * be shippable, which would be quite annoying.
434 */
456 }
457 }
459 /*
460 * If the constant has nondefault collation, either it's of a
461 * non-builtin type, or it reflects folding of a CollateExpr.
462 * It's unsafe to send to the remote unless it's used in a
463 * non-collation-sensitive context.
464 */
469 else
471 }
474 {
477 /*
478 * If it's a MULTIEXPR Param, punt. We can't tell from here
479 * whether the referenced sublink/subplan contains any remote
480 * Vars; if it does, handling that is too complicated to
481 * consider supporting at present. Fortunately, MULTIEXPR
482 * Params are not reduced to plain PARAM_EXEC until the end of
483 * planning, so we can easily detect this case. (Normal
484 * PARAM_EXEC Params are safe to ship because their values
485 * come from somewhere else in the plan tree; but a MULTIEXPR
486 * references a sub-select elsewhere in the same targetlist,
487 * so we'd be on the hook to evaluate it somehow if we wanted
488 * to handle such cases as direct foreign updates.)
489 */
493 /*
494 * Collation rule is same as for Consts and non-foreign Vars.
495 */
500 else
502 }
505 {
508 /* Assignment should not be in restrictions. */
512 /*
513 * Recurse into the remaining subexpressions. The container
514 * subscripts will not affect collation of the SubscriptingRef
515 * result, so do those first and reset inner_cxt afterwards.
516 */
531 /*
532 * Container subscripting typically yields same collation as
533 * refexpr's, but in case it doesn't, use same logic as for
534 * function nodes.
535 */
544 else
546 }
549 {
552 /*
553 * If function used by the expression is not shippable, it
554 * can't be sent to remote because it might have incompatible
555 * semantics on remote side.
556 */
560 /*
561 * Recurse to input subexpressions.
562 */
567 /*
568 * If function's input collation is not derived from a foreign
569 * Var, it can't be sent to remote.
570 */
577 /*
578 * Detect whether node is introducing a collation not derived
579 * from a foreign Var. (If so, we just mark it unsafe for now
580 * rather than immediately returning false, since the parent
581 * node might not care.)
582 */
591 else
593 }
597 {
600 /*
601 * Similarly, only shippable operators can be sent to remote.
602 * (If the operator is shippable, we assume its underlying
603 * function is too.)
604 */
608 /*
609 * Recurse to input subexpressions.
610 */
615 /*
616 * If operator's input collation is not derived from a foreign
617 * Var, it can't be sent to remote.
618 */
625 /* Result-collation handling is same as for functions */
634 else
636 }
639 {
642 /*
643 * Again, only shippable operators can be sent to remote.
644 */
648 /*
649 * Recurse to input subexpressions.
650 */
655 /*
656 * If operator's input collation is not derived from a foreign
657 * Var, it can't be sent to remote.
658 */
665 /* Output is always boolean and so noncollatable. */
668 }
671 {
674 /*
675 * Recurse to input subexpression.
676 */
681 /*
682 * RelabelType must not introduce a collation not derived from
683 * an input foreign Var (same logic as for a real function).
684 */
693 else
695 }
698 {
701 /*
702 * Recurse to input subexpressions.
703 */
708 /* Output is always boolean and so noncollatable. */
711 }
714 {
717 /*
718 * Recurse to input subexpressions.
719 */
724 /* Output is always boolean and so noncollatable. */
727 }
730 {
732 foreign_loc_cxt arg_cxt;
733 foreign_loc_cxt tmp_cxt;
736 /*
737 * Recurse to CASE's arg expression, if any. Its collation
738 * has to be saved aside for use while examining CaseTestExprs
739 * within the WHEN expressions.
740 */
744 {
748 }
750 /* Examine the CaseWhen subexpressions. */
752 {
756 {
757 /*
758 * In a CASE-with-arg, the parser should have produced
759 * WHEN clauses of the form "CaseTestExpr = RHS",
760 * possibly with an implicit coercion inserted above
761 * the CaseTestExpr. However in an expression that's
762 * been through the optimizer, the WHEN clause could
763 * be almost anything (since the equality operator
764 * could have been expanded into an inline function).
765 * In such cases forbid pushdown, because
766 * deparseCaseExpr can't handle it.
767 */
777 CaseTestExpr))
779 }
781 /*
782 * Recurse to WHEN expression, passing down the arg info.
783 * Its collation doesn't affect the result (really, it
784 * should be boolean and thus not have a collation).
785 */
792 /* Recurse to THEN expression. */
796 }
798 /* Recurse to ELSE expression. */
803 /*
804 * Detect whether node is introducing a collation not derived
805 * from a foreign Var. (If so, we just mark it unsafe for now
806 * rather than immediately returning false, since the parent
807 * node might not care.) This is the same as for function
808 * nodes, except that the input collation is derived from only
809 * the THEN and ELSE subexpressions.
810 */
819 else
821 }
824 {
827 /* Punt if we seem not to be inside a CASE arg WHEN. */
831 /*
832 * Otherwise, any nondefault collation attached to the
833 * CaseTestExpr node must be derived from foreign Var(s) in
834 * the CASE arg.
835 */
844 else
846 }
849 {
852 /*
853 * Recurse to input subexpressions.
854 */
859 /*
860 * ArrayExpr must not introduce a collation not derived from
861 * an input foreign Var (same logic as for a function).
862 */
871 else
873 }
876 {
880 /*
881 * Recurse to component subexpressions.
882 */
884 {
888 }
890 /*
891 * When processing a list, collation state just bubbles up
892 * from the list elements.
893 */
897 /* Don't apply exprType() to the list. */
899 }
902 {
906 /* Not safe to pushdown when not in grouping context */
910 /* Only non-split aggregates are pushable. */
914 /* As usual, it must be shippable. */
918 /*
919 * Recurse to input args. aggdirectargs, aggorder and
920 * aggdistinct are all present in args, so no need to check
921 * their shippability explicitly.
922 */
924 {
927 /* If TargetEntry, extract the expression from it */
929 {
933 }
938 }
940 /*
941 * For aggorder elements, check whether the sort operator, if
942 * specified, is shippable or not.
943 */
945 {
947 {
949 Oid sortcoltype;
958 /* Check shippability of non-default sort operator. */
962 fpinfo))
964 }
965 }
967 /* Check aggregate filter */
972 /*
973 * If aggregate's input collation is not derived from a
974 * foreign Var, it can't be sent to remote.
975 */
982 /*
983 * Detect whether node is introducing a collation not derived
984 * from a foreign Var. (If so, we just mark it unsafe for now
985 * rather than immediately returning false, since the parent
986 * node might not care.)
987 */
996 else
998 }
1002 /*
1003 * If it's anything else, assume it's unsafe. This list can be
1004 * expanded later, but don't forget to add deparse support below.
1005 */
1007 }
1009 /*
1010 * If result type of given expression is not shippable, it can't be sent
1011 * to remote because it might have incompatible semantics on remote side.
1012 */
1016 /*
1017 * Now, merge my collation information into my parent's state.
1018 */
1020 {
1021 /* Override previous parent state */
1024 }
1026 {
1027 /* Merge, or detect error if there's a collation conflict */
1029 {
1031 /* Nothing + nothing is still nothing */
1035 {
1036 /*
1037 * Non-default collation always beats default.
1038 */
1040 {
1041 /* Override previous parent state */
1043 }
1045 {
1046 /*
1047 * Conflict; show state as indeterminate. We don't
1048 * want to "return false" right away, since parent
1049 * node might not care about collation.
1050 */
1052 }
1053 }
1056 /* We're still conflicted ... */
1058 }
1059 }
1061 /* It looks OK */
1063 }
1065 /*
1066 * Returns true if given expr is something we'd have to send the value of
1067 * to the foreign server.
1068 *
1069 * This should return true when the expression is a shippable node that
1070 * deparseExpr would add to context->params_list. Note that we don't care
1071 * if the expression *contains* such a node, only whether one appears at top
1072 * level. We need this to detect cases where setrefs.c would recognize a
1073 * false match between an fdw_exprs item (which came from the params_list)
1074 * and an entry in fdw_scan_tlist (which we're considering putting the given
1075 * expression into).
1076 */
1077 bool
1081 {
1086 {
1088 {
1089 /* It would have to be sent unless it's a foreign Var */
1092 Relids relids;
1096 else
1101 else
1104 }
1106 /* Params always have to be sent to the foreign server */
1110 }
1112 }
1114 /*
1115 * Returns true if it's safe to push down the sort expression described by
1116 * 'pathkey' to the foreign server.
1117 */
1118 bool
1122 {
1126 /*
1127 * is_foreign_expr would detect volatile expressions as well, but checking
1128 * ec_has_volatile here saves some cycles.
1129 */
1133 /* can't push down the sort if the pathkey's opfamily is not shippable */
1137 /* can push if a suitable EC member exists */
1139 }
1141 /*
1142 * Convert type OID + typmod info into a type name we can ship to the remote
1143 * server. Someplace else had better have verified that this type name is
1144 * expected to be known on the remote end.
1145 *
1146 * This is almost just format_type_with_typemod(), except that if left to its
1147 * own devices, that function will make schema-qualification decisions based
1148 * on the local search_path, which is wrong. We must schema-qualify all
1149 * type names that are not in pg_catalog. We assume here that built-in types
1150 * are all in pg_catalog and need not be qualified; otherwise, qualify.
1151 */
1154 {
1161 }
1163 /*
1164 * Build the targetlist for given relation to be deparsed as SELECT clause.
1165 *
1166 * The output targetlist contains the columns that need to be fetched from the
1167 * foreign server for the given relation. If foreignrel is an upper relation,
1168 * then the output targetlist can also contain expressions to be evaluated on
1169 * foreign server.
1170 */
1171 List *
1173 {
1178 /*
1179 * For an upper relation, we have already built the target list while
1180 * checking shippability, so just return that.
1181 */
1185 /*
1186 * We require columns specified in foreignrel->reltarget->exprs and those
1187 * required for evaluating the local conditions.
1188 */
1191 PVC_RECURSE_PLACEHOLDERS));
1193 {
1198 PVC_RECURSE_PLACEHOLDERS));
1199 }
1202 }
1204 /*
1205 * Deparse SELECT statement for given relation into buf.
1206 *
1207 * tlist contains the list of desired columns to be fetched from foreign server.
1208 * For a base relation fpinfo->attrs_used is used to construct SELECT clause,
1209 * hence the tlist is ignored for a base relation.
1210 *
1211 * remote_conds is the list of conditions to be deparsed into the WHERE clause
1212 * (or, in the case of upper relations, into the HAVING clause).
1213 *
1214 * If params_list is not NULL, it receives a list of Params and other-relation
1215 * Vars used in the clauses; these values must be transmitted to the remote
1216 * server as parameter values.
1217 *
1218 * If params_list is NULL, we're generating the query for EXPLAIN purposes,
1219 * so Params and other-relation Vars should be replaced by dummy values.
1220 *
1221 * pathkeys is the list of pathkeys to order the result by.
1222 *
1223 * is_subquery is the flag to indicate whether to deparse the specified
1224 * relation as a subquery.
1225 *
1226 * List of columns selected is returned in retrieved_attrs.
1227 */
1228 void
1233 {
1234 deparse_expr_cxt context;
1238 /*
1239 * We handle relations for foreign tables, joins between those and upper
1240 * relations.
1241 */
1244 /* Fill portions of context common to upper, join and base relation */
1251 /* Construct SELECT clause */
1254 /*
1255 * For upper relations, the WHERE clause is built from the remote
1256 * conditions of the underlying scan relation; otherwise, we can use the
1257 * supplied list of remote conditions directly.
1258 */
1260 {
1265 }
1266 else
1269 /* Construct FROM and WHERE clauses */
1273 {
1274 /* Append GROUP BY clause */
1277 /* Append HAVING clause */
1279 {
1282 }
1283 }
1285 /* Add ORDER BY clause if we found any useful pathkeys */
1289 /* Add LIMIT clause if necessary */
1293 /* Add any necessary FOR UPDATE/SHARE. */
1295 }
1297 /*
1298 * Construct a simple SELECT statement that retrieves desired columns
1299 * of the specified foreign table, and append it to "buf". The output
1300 * contains just "SELECT ... ".
1301 *
1302 * We also create an integer List of the columns being retrieved, which is
1303 * returned to *retrieved_attrs, unless we deparse the specified relation
1304 * as a subquery.
1305 *
1306 * tlist is the list of desired columns. is_subquery is the flag to
1307 * indicate whether to deparse the specified relation as a subquery.
1308 * Read prologue of deparseSelectStmtForRel() for details.
1309 */
1310 static void
1313 {
1319 /*
1320 * Construct SELECT list
1321 */
1325 {
1326 /*
1327 * For a relation that is deparsed as a subquery, emit expressions
1328 * specified in the relation's reltarget. Note that since this is for
1329 * the subquery, no need to care about *retrieved_attrs.
1330 */
1332 }
1334 {
1335 /*
1336 * For a join or upper relation the input tlist gives the list of
1337 * columns required to be fetched from the foreign server.
1338 */
1340 }
1341 else
1342 {
1343 /*
1344 * For a base relation fpinfo->attrs_used gives the list of columns
1345 * required to be fetched from the foreign server.
1346 */
1349 /*
1350 * Core code already has some lock on each rel being planned, so we
1351 * can use NoLock here.
1352 */
1358 }
1359 }
1361 /*
1362 * Construct a FROM clause and, if needed, a WHERE clause, and append those to
1363 * "buf".
1364 *
1365 * quals is the list of clauses to be included in the WHERE clause.
1366 * (These may or may not include RestrictInfo decoration.)
1367 */
1368 static void
1370 {
1374 /* For upper relations, scanrel must be either a joinrel or a baserel */
1378 /* Construct FROM clause */
1384 /* Construct WHERE clause */
1386 {
1389 }
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 /* Output join name for given join type */
1604 {
1606 {
1620 /* Shouldn't come here, but protect from buggy code. */
1622 }
1624 /* Keep compiler happy */
1626 }
1628 /*
1629 * Deparse given targetlist and append it to context->buf.
1630 *
1631 * tlist is list of TargetEntry's which in turn contain Var nodes.
1632 *
1633 * retrieved_attrs is the list of continuously increasing integers starting
1634 * from 1. It has same number of entries as tlist.
1635 *
1636 * This is used for both SELECT and RETURNING targetlists; the is_returning
1637 * parameter is true only for a RETURNING targetlist.
1638 */
1639 static void
1644 {
1652 {
1663 i++;
1664 }
1668 }
1670 /*
1671 * Emit expressions specified in the given relation's reltarget.
1672 *
1673 * This is used for deparsing the given relation as a subquery.
1674 */
1675 static void
1677 {
1683 /* Should only be called in these cases. */
1688 {
1696 }
1698 /* Don't generate bad syntax if no expressions */
1701 }
1703 /*
1704 * Construct FROM clause for given relation
1705 *
1706 * The function constructs ... JOIN ... ON ... for join relation. For a base
1707 * relation it just returns schema-qualified tablename, with the appropriate
1708 * alias if so requested.
1709 *
1710 * 'ignore_rel' is either zero or the RT index of a target relation. In the
1711 * latter case the function constructs FROM clause of UPDATE or USING clause
1712 * of DELETE; it deparses the join relation as if the relation never contained
1713 * the target relation, and creates a List of conditions to be deparsed into
1714 * the top-level WHERE clause, which is returned to *ignore_conds.
1715 */
1716 static void
1720 {
1724 {
1725 StringInfoData join_sql_o;
1726 StringInfoData join_sql_i;
1733 {
1734 /*
1735 * If this is an inner join, add joinclauses to *ignore_conds and
1736 * set it to empty so that those can be deparsed into the WHERE
1737 * clause. Note that since the target relation can never be
1738 * within the nullable side of an outer join, those could safely
1739 * be pulled up into the WHERE clause (see foreign_join_ok()).
1740 * Note also that since the target relation is only inner-joined
1741 * to any other relation in the query, all conditions in the join
1742 * tree mentioning the target relation could be deparsed into the
1743 * WHERE clause by doing this recursively.
1744 */
1746 {
1750 }
1752 /*
1753 * Check if either of the input relations is the target relation.
1754 */
1759 }
1761 /* Deparse outer relation if not the target relation. */
1763 {
1769 /*
1770 * If inner relation is the target relation, skip deparsing it.
1771 * Note that since the join of the target relation with any other
1772 * relation in the query is an inner join and can never be within
1773 * the nullable side of an outer join, the join could be
1774 * interchanged with higher-level joins (cf. identity 1 on outer
1775 * join reordering shown in src/backend/optimizer/README), which
1776 * means it's safe to skip the target-relation deparsing here.
1777 */
1779 {
1784 }
1785 }
1787 /* Deparse inner relation if not the target relation. */
1789 {
1795 /*
1796 * If outer relation is the target relation, skip deparsing it.
1797 * See the above note about safety.
1798 */
1800 {
1805 }
1806 }
1808 /* Neither of the relations is the target relation. */
1811 /*
1812 * For a join relation FROM clause entry is deparsed as
1813 *
1814 * ((outer relation) <join type> (inner relation) ON (joinclauses))
1815 */
1819 /* Append join clause; (TRUE) if no join clause */
1821 {
1822 deparse_expr_cxt context;
1833 }
1834 else
1837 /* End the FROM clause entry. */
1839 }
1840 else
1841 {
1844 /*
1845 * Core code already has some lock on each rel being planned, so we
1846 * can use NoLock here.
1847 */
1852 /*
1853 * Add a unique alias to avoid any conflict in relation names due to
1854 * pulled up subqueries in the query being built for a pushed down
1855 * join.
1856 */
1861 }
1862 }
1864 /*
1865 * Append FROM clause entry for the given relation into buf.
1866 */
1867 static void
1871 {
1874 /* Should only be called in these cases. */
1879 /* If make_subquery is true, deparse the relation as a subquery. */
1881 {
1885 /*
1886 * The given relation shouldn't contain the target relation, because
1887 * this should only happen for input relations for a full join, and
1888 * such relations can never contain an UPDATE/DELETE target.
1889 */
1893 /* Deparse the subquery representing the relation. */
1901 /* Append the relation alias. */
1905 /*
1906 * Append the column aliases if needed. Note that the subquery emits
1907 * expressions specified in the relation's reltarget (see
1908 * deparseSubqueryTargetList).
1909 */
1912 {
1917 {
1922 }
1924 }
1925 }
1926 else
1929 }
1931 /*
1932 * deparse remote INSERT statement
1933 *
1934 * The statement text is appended to buf, and we also create an integer List
1935 * of the columns being retrieved by WITH CHECK OPTION or RETURNING (if any),
1936 * which is returned to *retrieved_attrs.
1937 *
1938 * This also stores end position of the VALUES clause, so that we can rebuild
1939 * an INSERT for a batch of rows later.
1940 */
1941 void
1947 {
1949 AttrNumber pindex;
1957 {
1962 {
1970 }
1977 {
1987 else
1988 {
1990 pindex++;
1991 }
1992 }
1995 }
1996 else
2006 }
2008 /*
2009 * rebuild remote INSERT statement
2010 *
2011 * Provided a number of rows in a batch, builds INSERT statement with the
2012 * right number of parameters.
2013 */
2014 void
2019 {
2026 /* Make sure the values_end_len is sensible */
2029 /* Copy up to the end of the first record from the original query */
2032 /*
2033 * Add records to VALUES clause (we already have parameters for the first
2034 * row, so start at the right offset).
2035 */
2038 {
2043 {
2053 else
2054 {
2056 pindex++;
2057 }
2058 }
2061 }
2063 /* Copy stuff after VALUES clause from the original query */
2065 }
2067 /*
2068 * deparse remote UPDATE statement
2069 *
2070 * The statement text is appended to buf, and we also create an integer List
2071 * of the columns being retrieved by WITH CHECK OPTION or RETURNING (if any),
2072 * which is returned to *retrieved_attrs.
2073 */
2074 void
2080 {
2082 AttrNumber pindex;
2093 {
2104 else
2105 {
2107 pindex++;
2108 }
2109 }
2115 }
2117 /*
2118 * deparse remote UPDATE statement
2119 *
2120 * 'buf' is the output buffer to append the statement to
2121 * 'rtindex' is the RT index of the associated target relation
2122 * 'rel' is the relation descriptor for the target relation
2123 * 'foreignrel' is the RelOptInfo for the target relation or the join relation
2124 * containing all base relations in the query
2125 * 'targetlist' is the tlist of the underlying foreign-scan plan node
2126 * (note that this only contains new-value expressions and junk attrs)
2127 * 'targetAttrs' is the target columns of the UPDATE
2128 * 'remote_conds' is the qual clauses that must be evaluated remotely
2129 * '*params_list' is an output list of exprs that will become remote Params
2130 * 'returningList' is the RETURNING targetlist
2131 * '*retrieved_attrs' is an output list of integers of columns being retrieved
2132 * by RETURNING (if any)
2133 */
2134 void
2144 {
2145 deparse_expr_cxt context;
2152 /* Set up context struct for recursion */
2165 /* Make sure any constants in the exprs are printed portably */
2170 {
2174 /* update's new-value expressions shouldn't be resjunk */
2184 }
2189 {
2196 }
2199 {
2202 }
2207 else
2210 }
2212 /*
2213 * deparse remote DELETE statement
2214 *
2215 * The statement text is appended to buf, and we also create an integer List
2216 * of the columns being retrieved by RETURNING (if any), which is returned
2217 * to *retrieved_attrs.
2218 */
2219 void
2224 {
2232 }
2234 /*
2235 * deparse remote DELETE statement
2236 *
2237 * 'buf' is the output buffer to append the statement to
2238 * 'rtindex' is the RT index of the associated target relation
2239 * 'rel' is the relation descriptor for the target relation
2240 * 'foreignrel' is the RelOptInfo for the target relation or the join relation
2241 * containing all base relations in the query
2242 * 'remote_conds' is the qual clauses that must be evaluated remotely
2243 * '*params_list' is an output list of exprs that will become remote Params
2244 * 'returningList' is the RETURNING targetlist
2245 * '*retrieved_attrs' is an output list of integers of columns being retrieved
2246 * by RETURNING (if any)
2247 */
2248 void
2256 {
2257 deparse_expr_cxt context;
2259 /* Set up context struct for recursion */
2272 {
2279 }
2282 {
2285 }
2290 else
2294 }
2296 /*
2297 * Add a RETURNING clause, if needed, to an INSERT/UPDATE/DELETE.
2298 */
2299 static void
2306 {
2310 {
2311 /* whole-row reference acquires all non-system columns */
2312 attrs_used =
2314 }
2317 {
2318 /*
2319 * We need the attrs, non-system and system, mentioned in the local
2320 * query's WITH CHECK OPTION list.
2321 *
2322 * Note: we do this to ensure that WCO constraints will be evaluated
2323 * on the data actually inserted/updated on the remote side, which
2324 * might differ from the data supplied by the core code, for example
2325 * as a result of remote triggers.
2326 */
2329 }
2332 {
2333 /*
2334 * We need the attrs, non-system and system, mentioned in the local
2335 * query's RETURNING list.
2336 */
2339 }
2343 retrieved_attrs);
2344 else
2346 }
2348 /*
2349 * Construct SELECT statement to acquire size in blocks of given relation.
2350 *
2351 * Note: we use local definition of block size, not remote definition.
2352 * This is perhaps debatable.
2353 *
2354 * Note: pg_relation_size() exists in 8.1 and later.
2355 */
2356 void
2358 {
2359 StringInfoData relname;
2361 /* We'll need the remote relation name as a literal. */
2368 }
2370 /*
2371 * Construct SELECT statement to acquire the number of rows and the relkind of
2372 * a relation.
2373 *
2374 * Note: we just return the remote server's reltuples value, which might
2375 * be off a good deal, but it doesn't seem worth working harder. See
2376 * comments in postgresAcquireSampleRowsFunc.
2377 */
2378 void
2380 {
2381 StringInfoData relname;
2383 /* We'll need the remote relation name as a literal. */
2387 appendStringInfoString(buf, "SELECT reltuples, relkind FROM pg_catalog.pg_class WHERE oid = ");
2390 }
2392 /*
2393 * Construct SELECT statement to acquire sample rows of given relation.
2394 *
2395 * SELECT command is appended to buf, and list of columns retrieved
2396 * is returned to *retrieved_attrs.
2397 *
2398 * We only support sampling methods we can decide based on server version.
2399 * Allowing custom TSM modules (like tsm_system_rows) might be useful, but it
2400 * would require detecting which extensions are installed, to allow automatic
2401 * fall-back. Moreover, the methods may use different parameters like number
2402 * of rows (and not sampling rate). So we leave this for future improvements.
2403 *
2404 * Using random() to sample rows on the remote server has the advantage that
2405 * this works on all PostgreSQL versions (unlike TABLESAMPLE), and that it
2406 * does the sampling on the remote side (without transferring everything and
2407 * then discarding most rows).
2408 *
2409 * The disadvantage is that we still have to read all rows and evaluate the
2410 * random(), while TABLESAMPLE (at least with the "system" method) may skip.
2411 * It's not that different from the "bernoulli" method, though.
2412 *
2413 * We could also do "ORDER BY random() LIMIT x", which would always pick
2414 * the expected number of rows, but it requires sorting so it may be much
2415 * more expensive (particularly on large tables, which is what the
2416 * remote sampling is meant to improve).
2417 */
2418 void
2422 {
2435 {
2436 /* Ignore dropped columns. */
2444 /* Use attribute name or column_name option. */
2449 {
2453 {
2456 }
2457 }
2462 }
2464 /* Don't generate bad syntax for zero-column relation. */
2468 /*
2469 * Construct FROM clause, and perhaps WHERE clause too, depending on the
2470 * selected sampling method.
2471 */
2476 {
2478 /* nothing to do here */
2494 /* should have been resolved into actual method */
2497 }
2498 }
2500 /*
2501 * Construct a simple "TRUNCATE rel" statement
2502 */
2503 void
2506 DropBehavior behavior,
2508 {
2514 {
2521 }
2530 }
2532 /*
2533 * Construct name to use for given column, and emit it into buf.
2534 * If it has a column_name FDW option, use that instead of attribute name.
2535 *
2536 * If qualify_col is true, qualify column name with the alias of relation.
2537 */
2538 static void
2541 {
2542 /* We support fetching the remote side's CTID and OID. */
2544 {
2548 }
2550 {
2551 /*
2552 * All other system attributes are fetched as 0, except for table OID,
2553 * which is fetched as the local table OID. However, we must be
2554 * careful; the table could be beneath an outer join, in which case it
2555 * must go to NULL whenever the rest of the row does.
2556 */
2563 {
2567 }
2568 else
2570 }
2572 {
2573 /* Whole row reference */
2574 Relation rel;
2577 /* Required only to be passed down to deparseTargetList(). */
2580 /*
2581 * The lock on the relation will be held by upper callers, so it's
2582 * fine to open it with no lock here.
2583 */
2586 /*
2587 * The local name of the foreign table can not be recognized by the
2588 * foreign server and the table it references on foreign server might
2589 * have different column ordering or different columns than those
2590 * declared locally. Hence we have to deparse whole-row reference as
2591 * ROW(columns referenced locally). Construct this by deparsing a
2592 * "whole row" attribute.
2593 */
2597 /*
2598 * In case the whole-row reference is under an outer join then it has
2599 * to go NULL whenever the rest of the row goes NULL. Deparsing a join
2600 * query would always involve multiple relations, thus qualify_col
2601 * would be true.
2602 */
2604 {
2608 }
2615 /* Complete the CASE WHEN statement started above. */
2621 }
2622 else
2623 {
2628 /* varno must not be any of OUTER_VAR, INNER_VAR and INDEX_VAR. */
2631 /*
2632 * If it's a column of a foreign table, and it has the column_name FDW
2633 * option, use that value.
2634 */
2637 {
2641 {
2644 }
2645 }
2647 /*
2648 * If it's a column of a regular table or it doesn't have column_name
2649 * FDW option, use attribute name.
2650 */
2658 }
2659 }
2661 /*
2662 * Append remote name of specified foreign table to buf.
2663 * Use value of table_name FDW option (if any) instead of relation's name.
2664 * Similarly, schema_name FDW option overrides schema name.
2665 */
2666 static void
2668 {
2674 /* obtain additional catalog information. */
2677 /*
2678 * Use value of FDW options if any, instead of the name of object itself.
2679 */
2681 {
2688 }
2690 /*
2691 * Note: we could skip printing the schema name if it's pg_catalog, but
2692 * that doesn't seem worth the trouble.
2693 */
2701 }
2703 /*
2704 * Append a SQL string literal representing "val" to buf.
2705 */
2706 void
2708 {
2711 /*
2712 * Rather than making assumptions about the remote server's value of
2713 * standard_conforming_strings, always use E'foo' syntax if there are any
2714 * backslashes. This will fail on remote servers before 8.1, but those
2715 * are long out of support.
2716 */
2721 {
2727 }
2729 }
2731 /*
2732 * Deparse given expression into context->buf.
2733 *
2734 * This function must support all the same node types that foreign_expr_walker
2735 * accepts.
2736 *
2737 * Note: unlike ruleutils.c, we just use a simple hard-wired parenthesization
2738 * scheme: anything more complex than a Var, Const, function call or cast
2739 * should be self-parenthesized.
2740 */
2741 static void
2743 {
2748 {
2795 }
2796 }
2798 /*
2799 * Deparse given Var node into context->buf.
2800 *
2801 * If the Var belongs to the foreign relation, just print its remote name.
2802 * Otherwise, it's effectively a Param (and will in fact be a Param at
2803 * run time). Handle it the same way we handle plain Params --- see
2804 * deparseParam for comments.
2805 */
2806 static void
2808 {
2813 /* Qualify columns when multiple relations are involved. */
2816 /*
2817 * If the Var belongs to the foreign relation that is deparsed as a
2818 * subquery, use the relation and column alias to the Var provided by the
2819 * subquery, instead of the remote name.
2820 */
2822 {
2827 }
2832 qualify_col);
2833 else
2834 {
2835 /* Treat like a Param */
2837 {
2841 /* find its index in params_list */
2843 {
2844 pindex++;
2847 }
2849 {
2850 /* not in list, so add it */
2851 pindex++;
2853 }
2856 }
2857 else
2858 {
2860 }
2861 }
2862 }
2864 /*
2865 * Deparse given constant value into context->buf.
2866 *
2867 * This function has to be kept in sync with ruleutils.c's get_const_expr.
2868 *
2869 * As in that function, showtype can be -1 to never show "::typename"
2870 * decoration, +1 to always show it, or 0 to show it only if the constant
2871 * wouldn't be assumed to be the right type by default.
2872 *
2873 * In addition, this code allows showtype to be -2 to indicate that we should
2874 * not show "::typename" decoration if the constant is printed as an untyped
2875 * literal or NULL (while in other cases, behaving as for showtype == 0).
2876 */
2877 static void
2879 {
2881 Oid typoutput;
2889 {
2896 }
2903 {
2911 {
2912 /*
2913 * No need to quote unless it's a special value such as 'NaN'.
2914 * See comments in get_const_expr().
2915 */
2917 {
2920 else
2924 }
2925 else
2927 }
2936 else
2943 }
2950 /*
2951 * For showtype == 0, append ::typename unless the constant will be
2952 * implicitly typed as the right type when it is read in.
2953 *
2954 * XXX this code has to be kept in sync with the behavior of the parser,
2955 * especially make_const.
2956 */
2958 {
2969 {
2970 /* label unless we printed it as an untyped string */
2972 }
2973 else
2976 }
2981 }
2983 /*
2984 * Deparse given Param node.
2985 *
2986 * If we're generating the query "for real", add the Param to
2987 * context->params_list if it's not already present, and then use its index
2988 * in that list as the remote parameter number. During EXPLAIN, there's
2989 * no need to identify a parameter number.
2990 */
2991 static void
2993 {
2995 {
2999 /* find its index in params_list */
3001 {
3002 pindex++;
3005 }
3007 {
3008 /* not in list, so add it */
3009 pindex++;
3011 }
3014 }
3015 else
3016 {
3018 }
3019 }
3021 /*
3022 * Deparse a container subscript expression.
3023 */
3024 static void
3026 {
3031 /* Always parenthesize the expression. */
3034 /*
3035 * Deparse referenced array expression first. If that expression includes
3036 * a cast, we have to parenthesize to prevent the array subscript from
3037 * being taken as typename decoration. We can avoid that in the typical
3038 * case of subscripting a Var, but otherwise do it.
3039 */
3042 else
3043 {
3047 }
3049 /* Deparse subscript expressions. */
3052 {
3055 {
3059 }
3062 }
3065 }
3067 /*
3068 * Deparse a function call.
3069 */
3070 static void
3072 {
3078 /*
3079 * If the function call came from an implicit coercion, then just show the
3080 * first argument.
3081 */
3083 {
3086 }
3088 /*
3089 * If the function call came from a cast, then show the first argument
3090 * plus an explicit cast operation.
3091 */
3093 {
3095 int32 coercedTypmod;
3097 /* Get the typmod if this is a length-coercion function */
3104 }
3106 /* Check if need to print VARIADIC (cf. ruleutils.c) */
3109 /*
3110 * Normal function: display as proname(args).
3111 */
3115 /* ... and all the arguments */
3118 {
3125 }
3127 }
3129 /*
3130 * Deparse given operator expression. To avoid problems around
3131 * priority of operations, we always parenthesize the arguments.
3132 */
3133 static void
3135 {
3137 HeapTuple tuple;
3138 Form_pg_operator form;
3143 /* Retrieve information about the operator from system catalog. */
3150 /* Sanity check. */
3156 /* Always parenthesize the expression. */
3159 /* Deparse left operand, if any. */
3161 {
3167 /*
3168 * When considering a binary operator, if one operand is a Const that
3169 * can be printed as a bare string literal or NULL (i.e., it will look
3170 * like type UNKNOWN to the remote parser), the Const normally
3171 * receives an explicit cast to the operator's input type. However,
3172 * in Const-to-Var comparisons where both operands are of the same
3173 * type, we prefer to suppress the explicit cast, leaving the Const's
3174 * type resolution up to the remote parser. The remote's resolution
3175 * heuristic will assume that an unknown input type being compared to
3176 * a known input type is of that known type as well.
3177 *
3178 * This hack allows some cases to succeed where a remote column is
3179 * declared with a different type in the local (foreign) table. By
3180 * emitting "foreigncol = 'foo'" not "foreigncol = 'foo'::text" or the
3181 * like, we allow the remote parser to pick an "=" operator that's
3182 * compatible with whatever type the remote column really is, such as
3183 * an enum.
3184 *
3185 * We allow cast suppression to happen only when the other operand is
3186 * a plain foreign Var. Although the remote's unknown-type heuristic
3187 * would apply to other cases just as well, we would be taking a
3188 * bigger risk that the inferred type is something unexpected. With
3189 * this restriction, if anything goes wrong it's the user's fault for
3190 * not declaring the local column with the same type as the remote
3191 * column.
3192 */
3194 {
3199 }
3203 else
3207 }
3209 /* Deparse operator name. */
3212 /* Deparse right operand. */
3217 else
3223 }
3225 /*
3226 * Will "node" deparse as a plain foreign Var?
3227 */
3228 static bool
3230 {
3231 /*
3232 * We allow the foreign Var to have an implicit RelabelType, mainly so
3233 * that this'll work with varchar columns. Note that deparseRelabelType
3234 * will not print such a cast, so we're not breaking the restriction that
3235 * the expression print as a plain Var. We won't risk it for an implicit
3236 * cast that requires a function, nor for non-implicit RelabelType; such
3237 * cases seem too likely to involve semantics changes compared to what
3238 * would happen on the remote side.
3239 */
3245 {
3246 /*
3247 * The Var must be one that'll deparse as a foreign column reference
3248 * (cf. deparseVar).
3249 */
3255 }
3258 }
3260 /*
3261 * Print the name of an operator.
3262 */
3263 static void
3265 {
3268 /* opname is not a SQL identifier, so we should not quote it. */
3271 /* Print schema name only if it's not pg_catalog */
3273 {
3277 /* Print fully qualified operator name. */
3280 }
3281 else
3282 {
3283 /* Just print operator name. */
3285 }
3286 }
3288 /*
3289 * Deparse IS DISTINCT FROM.
3290 */
3291 static void
3293 {
3303 }
3305 /*
3306 * Deparse given ScalarArrayOpExpr expression. To avoid problems
3307 * around priority of operations, we always parenthesize the arguments.
3308 */
3309 static void
3311 {
3313 HeapTuple tuple;
3314 Form_pg_operator form;
3318 /* Retrieve information about the operator from system catalog. */
3324 /* Sanity check. */
3327 /* Always parenthesize the expression. */
3330 /* Deparse left operand. */
3335 /* Deparse operator name plus decoration. */
3339 /* Deparse right operand. */
3345 /* Always parenthesize the expression. */
3349 }
3351 /*
3352 * Deparse a RelabelType (binary-compatible cast) node.
3353 */
3354 static void
3356 {
3362 }
3364 /*
3365 * Deparse a BoolExpr node.
3366 */
3367 static void
3369 {
3376 {
3388 }
3393 {
3398 }
3400 }
3402 /*
3403 * Deparse IS [NOT] NULL expression.
3404 */
3405 static void
3407 {
3413 /*
3414 * For scalar inputs, we prefer to print as IS [NOT] NULL, which is
3415 * shorter and traditional. If it's a rowtype input but we're applying a
3416 * scalar test, must print IS [NOT] DISTINCT FROM NULL to be semantically
3417 * correct.
3418 */
3420 {
3423 else
3425 }
3426 else
3427 {
3430 else
3432 }
3433 }
3435 /*
3436 * Deparse CASE expression
3437 */
3438 static void
3440 {
3446 /* If this is a CASE arg WHEN then emit the arg expression */
3448 {
3451 }
3453 /* Add each condition/result of the CASE clause */
3455 {
3458 /* WHEN */
3463 {
3464 /* Ignore the CaseTestExpr and equality operator. */
3466 context);
3467 }
3469 /* THEN */
3472 }
3474 /* add ELSE if present */
3476 {
3479 }
3481 /* append END */
3483 }
3485 /*
3486 * Deparse ARRAY[...] construct.
3487 */
3488 static void
3490 {
3497 {
3502 }
3505 /* If the array is empty, we need an explicit cast to the array type. */
3509 }
3511 /*
3512 * Deparse an Aggref node.
3513 */
3514 static void
3516 {
3520 /* Only basic, non-split aggregation accepted. */
3523 /* Check if need to print VARIADIC (cf. ruleutils.c) */
3526 /* Find aggregate name from aggfnoid which is a pg_proc entry */
3530 /* Add DISTINCT */
3534 {
3535 /* Add WITHIN GROUP (ORDER BY ..) */
3543 {
3549 }
3553 }
3554 else
3555 {
3556 /* aggstar can be set only in zero-argument aggregates */
3559 else
3560 {
3564 /* Add all the arguments */
3566 {
3577 /* Add VARIADIC */
3582 }
3583 }
3585 /* Add ORDER BY */
3587 {
3590 }
3591 }
3593 /* Add FILTER (WHERE ..) */
3595 {
3598 }
3601 }
3603 /*
3604 * Append ORDER BY within aggregate function.
3605 */
3606 static void
3608 {
3614 {
3622 /* Deparse the sort expression proper. */
3625 /* Add decoration as needed. */
3627 context);
3628 }
3629 }
3631 /*
3632 * Append the ASC, DESC, USING <OPERATOR> and NULLS FIRST / NULLS LAST parts
3633 * of an ORDER BY clause.
3634 */
3635 static void
3638 {
3642 /* See whether operator is default < or > for sort expr's datatype. */
3650 else
3651 {
3652 HeapTuple opertup;
3653 Form_pg_operator operform;
3657 /* Append operator name. */
3664 }
3668 else
3670 }
3672 /*
3673 * Print the representation of a parameter to be sent to the remote side.
3674 *
3675 * Note: we always label the Param's type explicitly rather than relying on
3676 * transmitting a numeric type OID in PQexecParams(). This allows us to
3677 * avoid assuming that types have the same OIDs on the remote side as they
3678 * do locally --- they need only have the same names.
3679 */
3680 static void
3683 {
3688 }
3690 /*
3691 * Print the representation of a placeholder for a parameter that will be
3692 * sent to the remote side at execution time.
3693 *
3694 * This is used when we're just trying to EXPLAIN the remote query.
3695 * We don't have the actual value of the runtime parameter yet, and we don't
3696 * want the remote planner to generate a plan that depends on such a value
3697 * anyway. Thus, we can't do something simple like "$1::paramtype".
3698 * Instead, we emit "((SELECT null::paramtype)::paramtype)".
3699 * In all extant versions of Postgres, the planner will see that as an unknown
3700 * constant value, which is what we want. This might need adjustment if we
3701 * ever make the planner flatten scalar subqueries. Note: the reason for the
3702 * apparently useless outer cast is to ensure that the representation as a
3703 * whole will be parsed as an a_expr and not a select_with_parens; the latter
3704 * would do the wrong thing in the context "x = ANY(...)".
3705 */
3706 static void
3709 {
3714 }
3716 /*
3717 * Deparse GROUP BY clause.
3718 */
3719 static void
3721 {
3727 /* Nothing to be done, if there's no GROUP BY clause in the query. */
3733 /*
3734 * Queries with grouping sets are not pushed down, so we don't expect
3735 * grouping sets here.
3736 */
3739 /*
3740 * We intentionally print query->groupClause not processed_groupClause,
3741 * leaving it to the remote planner to get rid of any redundant GROUP BY
3742 * items again. This is necessary in case processed_groupClause reduced
3743 * to empty, and in any case the redundancy situation on the remote might
3744 * be different than what we think here.
3745 */
3747 {
3755 }
3756 }
3758 /*
3759 * Deparse ORDER BY clause defined by the given pathkeys.
3760 *
3761 * The clause should use Vars from context->scanrel if !has_final_sort,
3762 * or from context->foreignrel's targetlist if has_final_sort.
3763 *
3764 * We find a suitable pathkey expression (some earlier step
3765 * should have verified that there is one) and deparse it.
3766 */
3767 static void
3770 {
3776 /* Make sure any constants in the exprs are printed portably */
3781 {
3785 Oid oprid;
3788 {
3789 /*
3790 * By construction, context->foreignrel is the input relation to
3791 * the final sort.
3792 */
3796 }
3797 else
3802 /*
3803 * We don't expect any error here; it would mean that shippability
3804 * wasn't verified earlier. For the same reason, we don't recheck
3805 * shippability of the sort operator.
3806 */
3812 /*
3813 * Lookup the operator corresponding to the strategy in the opclass.
3814 * The datatype used by the opfamily is not necessarily the same as
3815 * the expression type (for array types for example).
3816 */
3829 /*
3830 * Here we need to use the expression's actual type to discover
3831 * whether the desired operator will be the default or not.
3832 */
3837 }
3839 }
3841 /*
3842 * Deparse LIMIT/OFFSET clause.
3843 */
3844 static void
3846 {
3851 /* Make sure any constants in the exprs are printed portably */
3855 {
3858 }
3860 {
3863 }
3866 }
3868 /*
3869 * appendFunctionName
3870 * Deparses function name from given function oid.
3871 */
3872 static void
3874 {
3876 HeapTuple proctup;
3877 Form_pg_proc procform;
3885 /* Print schema name only if it's not pg_catalog */
3887 {
3892 }
3894 /* Always print the function name */
3899 }
3901 /*
3902 * Appends a sort or group clause.
3903 *
3904 * Like get_rule_sortgroupclause(), returns the expression tree, so caller
3905 * need not find it again.
3906 */
3910 {
3919 {
3920 /* Use column-number form when requested by caller. */
3923 }
3925 {
3926 /*
3927 * Force a typecast here so that we don't emit something like "GROUP
3928 * BY 2", which will be misconstrued as a column position rather than
3929 * a constant.
3930 */
3932 }
3935 else
3936 {
3937 /* Always parenthesize the expression. */
3941 }
3944 }
3947 /*
3948 * Returns true if given Var is deparsed as a subquery output column, in
3949 * which case, *relno and *colno are set to the IDs for the relation and
3950 * column alias to the Var provided by the subquery.
3951 */
3952 static bool
3954 {
3959 /* Should only be called in these cases. */
3962 /*
3963 * If the given relation isn't a join relation, it doesn't have any lower
3964 * subqueries, so the Var isn't a subquery output column.
3965 */
3969 /*
3970 * If the Var doesn't belong to any lower subqueries, it isn't a subquery
3971 * output column.
3972 */
3977 {
3978 /*
3979 * If outer relation is deparsed as a subquery, the Var is an output
3980 * column of the subquery; get the IDs for the relation/column alias.
3981 */
3983 {
3986 }
3988 /* Otherwise, recurse into the outer relation. */
3990 }
3991 else
3992 {
3995 /*
3996 * If inner relation is deparsed as a subquery, the Var is an output
3997 * column of the subquery; get the IDs for the relation/column alias.
3998 */
4000 {
4003 }
4005 /* Otherwise, recurse into the inner relation. */
4007 }
4008 }
4010 /*
4011 * Get the IDs for the relation and column alias to given Var belonging to
4012 * given relation, which are returned into *relno and *colno.
4013 */
4014 static void
4017 {
4022 /* Get the relation alias ID */
4025 /* Get the column alias ID */
4028 {
4031 /*
4032 * Match reltarget entries only on varno/varattno. Ideally there
4033 * would be some cross-check on varnullingrels, but it's unclear what
4034 * to do exactly; we don't have enough context to know what that value
4035 * should be.
4036 */
4040 {
4043 }
4044 i++;
4045 }
4047 /* Shouldn't get here */
4049 }