| blob | 1393716587e9eba881ed1b3f55bc7023036bbd72 |
1 /*-------------------------------------------------------------------------
2 *
3 * postgres_fdw.c
4 * Foreign-data wrapper for remote PostgreSQL servers
5 *
6 * Portions Copyright (c) 2012-2023, PostgreSQL Global Development Group
7 *
8 * IDENTIFICATION
9 * contrib/postgres_fdw/postgres_fdw.c
10 *
11 *-------------------------------------------------------------------------
12 */
15 #include <limits.h>
54 PG_MODULE_MAGIC;
56 /* Default CPU cost to start up a foreign query. */
57 #define DEFAULT_FDW_STARTUP_COST 100.0
59 /* Default CPU cost to process 1 row (above and beyond cpu_tuple_cost). */
60 #define DEFAULT_FDW_TUPLE_COST 0.01
62 /* If no remote estimates, assume a sort costs 20% extra */
63 #define DEFAULT_FDW_SORT_MULTIPLIER 1.2
65 /*
66 * Indexes of FDW-private information stored in fdw_private lists.
67 *
68 * These items are indexed with the enum FdwScanPrivateIndex, so an item
69 * can be fetched with list_nth(). For example, to get the SELECT statement:
70 * sql = strVal(list_nth(fdw_private, FdwScanPrivateSelectSql));
71 */
72 enum FdwScanPrivateIndex
73 {
74 /* SQL statement to execute remotely (as a String node) */
75 FdwScanPrivateSelectSql,
76 /* Integer list of attribute numbers retrieved by the SELECT */
77 FdwScanPrivateRetrievedAttrs,
78 /* Integer representing the desired fetch_size */
79 FdwScanPrivateFetchSize,
81 /*
82 * String describing join i.e. names of relations being joined and types
83 * of join, added when the scan is join
84 */
85 FdwScanPrivateRelations
86 };
88 /*
89 * Similarly, this enum describes what's kept in the fdw_private list for
90 * a ModifyTable node referencing a postgres_fdw foreign table. We store:
91 *
92 * 1) INSERT/UPDATE/DELETE statement text to be sent to the remote server
93 * 2) Integer list of target attribute numbers for INSERT/UPDATE
94 * (NIL for a DELETE)
95 * 3) Length till the end of VALUES clause for INSERT
96 * (-1 for a DELETE/UPDATE)
97 * 4) Boolean flag showing if the remote query has a RETURNING clause
98 * 5) Integer list of attribute numbers retrieved by RETURNING, if any
99 */
100 enum FdwModifyPrivateIndex
101 {
102 /* SQL statement to execute remotely (as a String node) */
103 FdwModifyPrivateUpdateSql,
104 /* Integer list of target attribute numbers for INSERT/UPDATE */
105 FdwModifyPrivateTargetAttnums,
106 /* Length till the end of VALUES clause (as an Integer node) */
107 FdwModifyPrivateLen,
108 /* has-returning flag (as a Boolean node) */
109 FdwModifyPrivateHasReturning,
110 /* Integer list of attribute numbers retrieved by RETURNING */
111 FdwModifyPrivateRetrievedAttrs
112 };
114 /*
115 * Similarly, this enum describes what's kept in the fdw_private list for
116 * a ForeignScan node that modifies a foreign table directly. We store:
117 *
118 * 1) UPDATE/DELETE statement text to be sent to the remote server
119 * 2) Boolean flag showing if the remote query has a RETURNING clause
120 * 3) Integer list of attribute numbers retrieved by RETURNING, if any
121 * 4) Boolean flag showing if we set the command es_processed
122 */
123 enum FdwDirectModifyPrivateIndex
124 {
125 /* SQL statement to execute remotely (as a String node) */
126 FdwDirectModifyPrivateUpdateSql,
127 /* has-returning flag (as a Boolean node) */
128 FdwDirectModifyPrivateHasReturning,
129 /* Integer list of attribute numbers retrieved by RETURNING */
130 FdwDirectModifyPrivateRetrievedAttrs,
131 /* set-processed flag (as a Boolean node) */
132 FdwDirectModifyPrivateSetProcessed
133 };
135 /*
136 * Execution state of a foreign scan using postgres_fdw.
137 */
139 {
141 * for a foreign join scan. */
145 /* extracted fdw_private data */
149 /* for remote query execution */
159 /* for storing result tuples */
164 /* batch-level state, for optimizing rewinds and avoiding useless fetch */
168 /* for asynchronous execution */
171 /* working memory contexts */
178 /*
179 * Execution state of a foreign insert/update/delete operation.
180 */
182 {
186 /* for remote query execution */
191 /* extracted fdw_private data */
200 /* info about parameters for prepared statement */
205 /* batch operation stuff */
208 /* working memory context */
211 /* for update row movement if subplan result rel */
213 * created */
216 /*
217 * Execution state of a foreign scan that modifies a foreign table directly.
218 */
220 {
224 /* extracted fdw_private data */
230 /* for remote query execution */
238 /* for storing result tuples */
248 /* working memory context */
252 /*
253 * Workspace for analyzing a foreign table.
254 */
256 {
261 /* collected sample rows */
266 /* for random sampling */
271 /* working memory contexts */
276 /*
277 * This enum describes what's kept in the fdw_private list for a ForeignPath.
278 * We store:
279 *
280 * 1) Boolean flag showing if the remote query has the final sort
281 * 2) Boolean flag showing if the remote query has the LIMIT clause
282 */
283 enum FdwPathPrivateIndex
284 {
285 /* has-final-sort flag (as a Boolean node) */
286 FdwPathPrivateHasFinalSort,
287 /* has-limit flag (as a Boolean node) */
288 FdwPathPrivateHasLimit
289 };
291 /* Struct for extra information passed to estimate_path_cost_size() */
293 {
298 int64 count_est;
299 int64 offset_est;
302 /*
303 * Identify the attribute where data conversion fails.
304 */
306 {
312 /* Callback argument for ec_member_matches_foreign */
314 {
319 /*
320 * SQL functions
321 */
324 /*
325 * FDW callback routines
326 */
329 Oid foreigntableid);
332 Oid foreigntableid);
335 Oid foreigntableid,
345 Index rtindex,
347 Relation target_relation);
350 Index resultRelation,
384 Index resultRelation,
399 DropBehavior behavior,
405 Oid serverOid);
410 JoinType jointype,
415 UpperRelationKind stage,
424 /*
425 * Helper functions
426 */
457 CmdType operation,
466 CmdType operation,
472 ItemPointer tupleid,
486 Index rtindex);
512 Relation rel,
516 MemoryContext temp_context);
547 /*
548 * Foreign-data wrapper handler function: return a struct with pointers
549 * to my callback routines.
550 */
551 Datum
553 {
556 /* Functions for scanning foreign tables */
565 /* Functions for updating foreign tables */
583 /* Function for EvalPlanQual rechecks */
585 /* Support functions for EXPLAIN */
590 /* Support function for TRUNCATE */
593 /* Support functions for ANALYZE */
596 /* Support functions for IMPORT FOREIGN SCHEMA */
599 /* Support functions for join push-down */
602 /* Support functions for upper relation push-down */
605 /* Support functions for asynchronous execution */
612 }
614 /*
615 * postgresGetForeignRelSize
616 * Estimate # of rows and width of the result of the scan
617 *
618 * We should consider the effect of all baserestrictinfo clauses here, but
619 * not any join clauses.
620 */
621 static void
624 Oid foreigntableid)
625 {
629 /*
630 * We use PgFdwRelationInfo to pass various information to subsequent
631 * functions.
632 */
636 /* Base foreign tables need to be pushed down always. */
639 /* Look up foreign-table catalog info. */
643 /*
644 * Extract user-settable option values. Note that per-table settings of
645 * use_remote_estimate, fetch_size and async_capable override per-server
646 * settings of them, respectively.
647 */
658 /*
659 * If the table or the server is configured to use remote estimates,
660 * identify which user to do remote access as during planning. This
661 * should match what ExecCheckPermissions() does. If we fail due to lack
662 * of permissions, the query would have failed at runtime anyway.
663 */
665 {
666 Oid userid;
670 }
671 else
674 /*
675 * Identify which baserestrictinfo clauses can be sent to the remote
676 * server and which can't.
677 */
681 /*
682 * Identify which attributes will need to be retrieved from the remote
683 * server. These include all attrs needed for joins or final output, plus
684 * all attrs used in the local_conds. (Note: if we end up using a
685 * parameterized scan, it's possible that some of the join clauses will be
686 * sent to the remote and thus we wouldn't really need to retrieve the
687 * columns used in them. Doesn't seem worth detecting that case though.)
688 */
693 {
698 }
700 /*
701 * Compute the selectivity and cost of the local_conds, so we don't have
702 * to do it over again for each path. The best we can do for these
703 * conditions is to estimate selectivity on the basis of local statistics.
704 */
708 JOIN_INNER,
709 NULL);
713 /*
714 * Set # of retrieved rows and cached relation costs to some negative
715 * value, so that we can detect when they are set to some sensible values,
716 * during one (usually the first) of the calls to estimate_path_cost_size.
717 */
722 /*
723 * If the table or the server is configured to use remote estimates,
724 * connect to the foreign server and execute EXPLAIN to estimate the
725 * number of rows selected by the restriction clauses, as well as the
726 * average row width. Otherwise, estimate using whatever statistics we
727 * have locally, in a way similar to ordinary tables.
728 */
730 {
731 /*
732 * Get cost/size estimates with help of remote server. Save the
733 * values in fpinfo so we don't need to do it again to generate the
734 * basic foreign path.
735 */
740 /* Report estimated baserel size to planner. */
743 }
744 else
745 {
746 /*
747 * If the foreign table has never been ANALYZEd, it will have
748 * reltuples < 0, meaning "unknown". We can't do much if we're not
749 * allowed to consult the remote server, but we can use a hack similar
750 * to plancat.c's treatment of empty relations: use a minimum size
751 * estimate of 10 pages, and divide by the column-datatype-based width
752 * estimate to get the corresponding number of tuples.
753 */
755 {
760 }
762 /* Estimate baserel size as best we can with local statistics. */
765 /* Fill in basically-bogus cost estimates for use later. */
769 }
771 /*
772 * fpinfo->relation_name gets the numeric rangetable index of the foreign
773 * table RTE. (If this query gets EXPLAIN'd, we'll convert that to a
774 * human-readable string at that time.)
775 */
778 /* No outer and inner relations. */
782 /* Set the relation index. */
784 }
786 /*
787 * get_useful_ecs_for_relation
788 * Determine which EquivalenceClasses might be involved in useful
789 * orderings of this relation.
790 *
791 * This function is in some respects a mirror image of the core function
792 * pathkeys_useful_for_merging: for a regular table, we know what indexes
793 * we have and want to test whether any of them are useful. For a foreign
794 * table, we don't know what indexes are present on the remote side but
795 * want to speculate about which ones we'd like to use if they existed.
796 *
797 * This function returns a list of potentially-useful equivalence classes,
798 * but it does not guarantee that an EquivalenceMember exists which contains
799 * Vars only from the given relation. For example, given ft1 JOIN t1 ON
800 * ft1.x + t1.x = 0, this function will say that the equivalence class
801 * containing ft1.x + t1.x is potentially useful. Supposing ft1 is remote and
802 * t1 is local (or on a different server), it will turn out that no useful
803 * ORDER BY clause can be generated. It's not our job to figure that out
804 * here; we're only interested in identifying relevant ECs.
805 */
808 {
811 Relids relids;
813 /*
814 * First, consider whether any active EC is potentially useful for a merge
815 * join against this relation.
816 */
818 {
820 {
825 }
826 }
828 /*
829 * Next, consider whether there are any non-EC derivable join clauses that
830 * are merge-joinable. If the joininfo list is empty, we can exit
831 * quickly.
832 */
836 /* If this is a child rel, we must use the topmost parent rel to search. */
838 {
841 }
842 else
845 /* Check each join clause in turn. */
847 {
850 /* Consider only mergejoinable clauses */
854 /* Make sure we've got canonical ECs. */
857 /*
858 * restrictinfo->mergeopfamilies != NIL is sufficient to guarantee
859 * that left_ec and right_ec will be initialized, per comments in
860 * distribute_qual_to_rels.
861 *
862 * We want to identify which side of this merge-joinable clause
863 * contains columns from the relation produced by this RelOptInfo. We
864 * test for overlap, not containment, because there could be extra
865 * relations on either side. For example, suppose we've got something
866 * like ((A JOIN B ON A.x = B.x) JOIN C ON A.y = C.y) LEFT JOIN D ON
867 * A.y = D.y. The input rel might be the joinrel between A and B, and
868 * we'll consider the join clause A.y = D.y. relids contains a
869 * relation not involved in the join class (B) and the equivalence
870 * class for the left-hand side of the clause contains a relation not
871 * involved in the input rel (C). Despite the fact that we have only
872 * overlap and not containment in either direction, A.y is potentially
873 * useful as a sort column.
874 *
875 * Note that it's even possible that relids overlaps neither side of
876 * the join clause. For example, consider A LEFT JOIN B ON A.x = B.x
877 * AND A.x = 1. The clause A.x = 1 will appear in B's joininfo list,
878 * but overlaps neither side of B. In that case, we just skip this
879 * join clause, since it doesn't suggest a useful sort order for this
880 * relation.
881 */
888 }
891 }
893 /*
894 * get_useful_pathkeys_for_relation
895 * Determine which orderings of a relation might be useful.
896 *
897 * Getting data in sorted order can be useful either because the requested
898 * order matches the final output ordering for the overall query we're
899 * planning, or because it enables an efficient merge join. Here, we try
900 * to figure out which pathkeys to consider.
901 */
904 {
911 /*
912 * Pushing the query_pathkeys to the remote server is always worth
913 * considering, because it might let us avoid a local sort.
914 */
917 {
921 {
924 /*
925 * The planner and executor don't have any clever strategy for
926 * taking data sorted by a prefix of the query's pathkeys and
927 * getting it to be sorted by all of those pathkeys. We'll just
928 * end up resorting the entire data set. So, unless we can push
929 * down all of the query pathkeys, forget it.
930 */
932 {
935 }
936 }
939 {
942 }
943 }
945 /*
946 * Even if we're not using remote estimates, having the remote side do the
947 * sort generally won't be any worse than doing it locally, and it might
948 * be much better if the remote side can generate data in the right order
949 * without needing a sort at all. However, what we're going to do next is
950 * try to generate pathkeys that seem promising for possible merge joins,
951 * and that's more speculative. A wrong choice might hurt quite a bit, so
952 * bail out if we can't use remote estimates.
953 */
957 /* Get the list of interesting EquivalenceClasses. */
960 /* Extract unique EC for query, if any, so we don't consider it again. */
962 {
966 }
968 /*
969 * As a heuristic, the only pathkeys we consider here are those of length
970 * one. It's surely possible to consider more, but since each one we
971 * choose to consider will generate a round-trip to the remote side, we
972 * need to be a bit cautious here. It would sure be nice to have a local
973 * cache of information about remote index definitions...
974 */
976 {
980 /* If redundant with what we did above, skip it. */
984 /* Can't push down the sort if the EC's opfamily is not shippable. */
989 /* If no pushable expression for this rel, skip it. */
993 /* Looks like we can generate a pathkey, so let's do it. */
996 BTLessStrategyNumber,
1000 }
1003 }
1005 /*
1006 * postgresGetForeignPaths
1007 * Create possible scan paths for a scan on the foreign table
1008 */
1009 static void
1012 Oid foreigntableid)
1013 {
1019 /*
1020 * Create simplest ForeignScan path node and add it to baserel. This path
1021 * corresponds to SeqScan path of regular tables (though depending on what
1022 * baserestrict conditions we were able to send to remote, there might
1023 * actually be an indexscan happening there). We already did all the work
1024 * to estimate cost and size of this path.
1025 *
1026 * Although this path uses no join clauses, it could still have required
1027 * parameterization due to LATERAL refs in its tlist.
1028 */
1041 /* Add paths with pathkeys */
1044 /*
1045 * If we're not using remote estimates, stop here. We have no way to
1046 * estimate whether any join clauses would be worth sending across, so
1047 * don't bother building parameterized paths.
1048 */
1052 /*
1053 * Thumb through all join clauses for the rel to identify which outer
1054 * relations could supply one or more safe-to-send-to-remote join clauses.
1055 * We'll build a parameterized path for each such outer relation.
1056 *
1057 * It's convenient to manage this by representing each candidate outer
1058 * relation by the ParamPathInfo node for it. We can then use the
1059 * ppi_clauses list in the ParamPathInfo node directly as a list of the
1060 * interesting join clauses for that rel. This takes care of the
1061 * possibility that there are multiple safe join clauses for such a rel,
1062 * and also ensures that we account for unsafe join clauses that we'll
1063 * still have to enforce locally (since the parameterized-path machinery
1064 * insists that we handle all movable clauses).
1065 */
1068 {
1070 Relids required_outer;
1073 /* Check if clause can be moved to this rel */
1077 /* See if it is safe to send to remote */
1081 /* Calculate required outer rels for the resulting path */
1084 /* We do not want the foreign rel itself listed in required_outer */
1087 /*
1088 * required_outer probably can't be empty here, but if it were, we
1089 * couldn't make a parameterized path.
1090 */
1094 /* Get the ParamPathInfo */
1096 required_outer);
1099 /*
1100 * Add it to list unless we already have it. Testing pointer equality
1101 * is OK since get_baserel_parampathinfo won't make duplicates.
1102 */
1104 }
1106 /*
1107 * The above scan examined only "generic" join clauses, not those that
1108 * were absorbed into EquivalenceClauses. See if we can make anything out
1109 * of EquivalenceClauses.
1110 */
1112 {
1113 /*
1114 * We repeatedly scan the eclass list looking for column references
1115 * (or expressions) belonging to the foreign rel. Each time we find
1116 * one, we generate a list of equivalence joinclauses for it, and then
1117 * see if any are safe to send to the remote. Repeat till there are
1118 * no more candidate EC members.
1119 */
1120 ec_member_foreign_arg arg;
1124 {
1127 /* Make clauses, skipping any that join to lateral_referencers */
1130 baserel,
1131 ec_member_matches_foreign,
1135 /* Done if there are no more expressions in the foreign rel */
1137 {
1140 }
1142 /* Scan the extracted join clauses */
1144 {
1146 Relids required_outer;
1149 /* Check if clause can be moved to this rel */
1153 /* See if it is safe to send to remote */
1157 /* Calculate required outer rels for the resulting path */
1164 /* Get the ParamPathInfo */
1166 required_outer);
1169 /* Add it to list unless we already have it */
1171 }
1173 /* Try again, now ignoring the expression we found this time */
1175 }
1176 }
1178 /*
1179 * Now build a path for each useful outer relation.
1180 */
1182 {
1186 Cost startup_cost;
1187 Cost total_cost;
1189 /* Get a cost estimate from the remote */
1195 /*
1196 * ppi_rows currently won't get looked at by anything, but still we
1197 * may as well ensure that it matches our idea of the rowcount.
1198 */
1201 /* Make the path */
1204 rows,
1205 startup_cost,
1206 total_cost,
1209 NULL,
1213 }
1214 }
1216 /*
1217 * postgresGetForeignPlan
1218 * Create ForeignScan plan node which implements selected best path
1219 */
1223 Oid foreigntableid,
1228 {
1230 Index scan_relid;
1238 StringInfoData sql;
1243 /*
1244 * Get FDW private data created by postgresGetForeignUpperPaths(), if any.
1245 */
1247 {
1249 FdwPathPrivateHasFinalSort));
1251 FdwPathPrivateHasLimit));
1252 }
1255 {
1256 /*
1257 * For base relations, set scan_relid as the relid of the relation.
1258 */
1261 /*
1262 * In a base-relation scan, we must apply the given scan_clauses.
1263 *
1264 * Separate the scan_clauses into those that can be executed remotely
1265 * and those that can't. baserestrictinfo clauses that were
1266 * previously determined to be safe or unsafe by classifyConditions
1267 * are found in fpinfo->remote_conds and fpinfo->local_conds. Anything
1268 * else in the scan_clauses list will be a join clause, which we have
1269 * to check for remote-safety.
1270 *
1271 * Note: the join clauses we see here should be the exact same ones
1272 * previously examined by postgresGetForeignPaths. Possibly it'd be
1273 * worth passing forward the classification work done then, rather
1274 * than repeating it here.
1275 *
1276 * This code must match "extract_actual_clauses(scan_clauses, false)"
1277 * except for the additional decision about remote versus local
1278 * execution.
1279 */
1281 {
1284 /* Ignore any pseudoconstants, they're dealt with elsewhere */
1294 else
1296 }
1298 /*
1299 * For a base-relation scan, we have to support EPQ recheck, which
1300 * should recheck all the remote quals.
1301 */
1303 }
1304 else
1305 {
1306 /*
1307 * Join relation or upper relation - set scan_relid to 0.
1308 */
1311 /*
1312 * For a join rel, baserestrictinfo is NIL and we are not considering
1313 * parameterization right now, so there should be no scan_clauses for
1314 * a joinrel or an upper rel either.
1315 */
1318 /*
1319 * Instead we get the conditions to apply from the fdw_private
1320 * structure.
1321 */
1325 /*
1326 * We leave fdw_recheck_quals empty in this case, since we never need
1327 * to apply EPQ recheck clauses. In the case of a joinrel, EPQ
1328 * recheck is handled elsewhere --- see postgresGetForeignJoinPaths().
1329 * If we're planning an upperrel (ie, remote grouping or aggregation)
1330 * then there's no EPQ to do because SELECT FOR UPDATE wouldn't be
1331 * allowed, and indeed we *can't* put the remote clauses into
1332 * fdw_recheck_quals because the unaggregated Vars won't be available
1333 * locally.
1334 */
1336 /* Build the list of columns to be fetched from the foreign server. */
1339 /*
1340 * Ensure that the outer plan produces a tuple whose descriptor
1341 * matches our scan tuple slot. Also, remove the local conditions
1342 * from outer plan's quals, lest they be evaluated twice, once by the
1343 * local plan and once by the scan.
1344 */
1346 {
1347 /*
1348 * Right now, we only consider grouping and aggregation beyond
1349 * joins. Queries involving aggregates or grouping do not require
1350 * EPQ mechanism, hence should not have an outer plan here.
1351 */
1354 /*
1355 * First, update the plan's qual list if possible. In some cases
1356 * the quals might be enforced below the topmost plan level, in
1357 * which case we'll fail to remove them; it's not worth working
1358 * harder than this.
1359 */
1361 {
1366 /*
1367 * For an inner join the local conditions of foreign scan plan
1368 * can be part of the joinquals as well. (They might also be
1369 * in the mergequals or hashquals, but we can't touch those
1370 * without breaking the plan.)
1371 */
1375 {
1380 qual);
1381 }
1382 }
1384 /*
1385 * Now fix the subplan's tlist --- this might result in inserting
1386 * a Result node atop the plan tree.
1387 */
1390 }
1391 }
1393 /*
1394 * Build the query string to be sent for execution, and identify
1395 * expressions to be sent as parameters.
1396 */
1403 /* Remember remote_exprs for possible use by postgresPlanDirectModify */
1406 /*
1407 * Build the fdw_private list that will be available to the executor.
1408 * Items in the list must match order in enum FdwScanPrivateIndex.
1409 */
1411 retrieved_attrs,
1417 /*
1418 * Create the ForeignScan node for the given relation.
1419 *
1420 * Note that the remote parameter expressions are stored in the fdw_exprs
1421 * field of the finished plan node; we can't keep them in private state
1422 * because then they wouldn't be subject to later planner processing.
1423 */
1425 local_exprs,
1426 scan_relid,
1427 params_list,
1428 fdw_private,
1429 fdw_scan_tlist,
1430 fdw_recheck_quals,
1431 outer_plan);
1432 }
1434 /*
1435 * Construct a tuple descriptor for the scan tuples handled by a foreign join.
1436 */
1437 static TupleDesc
1439 {
1442 TupleDesc tupdesc;
1444 /*
1445 * The core code has already set up a scan tuple slot based on
1446 * fsplan->fdw_scan_tlist, and this slot's tupdesc is mostly good enough,
1447 * but there's one case where it isn't. If we have any whole-row row
1448 * identifier Vars, they may have vartype RECORD, and we need to replace
1449 * that with the associated table's actual composite type. This ensures
1450 * that when we read those ROW() expression values from the remote server,
1451 * we can convert them to a composite type the local server knows.
1452 */
1455 {
1459 Oid reltype;
1461 /* Nothing to do if it's not a generic RECORD attribute */
1465 /*
1466 * If we can't identify the referenced table, do nothing. This'll
1467 * likely lead to failure later, but perhaps we can muddle through.
1468 */
1480 /* shouldn't need to change anything else */
1481 }
1483 }
1485 /*
1486 * postgresBeginForeignScan
1487 * Initiate an executor scan of a foreign PostgreSQL table.
1488 */
1489 static void
1491 {
1496 Oid userid;
1502 /*
1503 * Do nothing in EXPLAIN (no ANALYZE) case. node->fdw_state stays NULL.
1504 */
1508 /*
1509 * We'll save private state in node->fdw_state.
1510 */
1514 /*
1515 * Identify which user to do the remote access as. This should match what
1516 * ExecCheckPermissions() does.
1517 */
1521 else
1525 /* Get info about foreign table. */
1529 /*
1530 * Get connection to the foreign server. Connection manager will
1531 * establish new connection if necessary.
1532 */
1535 /* Assign a unique ID for my cursor */
1539 /* Get private info created by planner functions. */
1541 FdwScanPrivateSelectSql));
1543 FdwScanPrivateRetrievedAttrs);
1545 FdwScanPrivateFetchSize));
1547 /* Create contexts for batches of tuples and per-tuple temp workspace. */
1550 ALLOCSET_DEFAULT_SIZES);
1553 ALLOCSET_SMALL_SIZES);
1555 /*
1556 * Get info we'll need for converting data fetched from the foreign server
1557 * into local representation and error reporting during that process.
1558 */
1560 {
1563 }
1564 else
1565 {
1568 }
1572 /*
1573 * Prepare for processing of parameters used in remote query, if any.
1574 */
1580 numParams,
1585 /* Set the async-capable flag */
1587 }
1589 /*
1590 * postgresIterateForeignScan
1591 * Retrieve next row from the result set, or clear tuple slot to indicate
1592 * EOF.
1593 */
1596 {
1600 /*
1601 * In sync mode, if this is the first call after Begin or ReScan, we need
1602 * to create the cursor on the remote side. In async mode, we would have
1603 * already created the cursor before we get here, even if this is the
1604 * first call after Begin or ReScan.
1605 */
1609 /*
1610 * Get some more tuples, if we've run out.
1611 */
1613 {
1614 /* In async mode, just clear tuple slot. */
1617 /* No point in another fetch if we already detected EOF, though. */
1620 /* If we didn't get any tuples, must be end of data. */
1623 }
1625 /*
1626 * Return the next tuple.
1627 */
1629 slot,
1633 }
1635 /*
1636 * postgresReScanForeignScan
1637 * Restart the scan.
1638 */
1639 static void
1641 {
1646 /* If we haven't created the cursor yet, nothing to do. */
1650 /*
1651 * If the node is async-capable, and an asynchronous fetch for it has
1652 * begun, the asynchronous fetch might not have yet completed. Check if
1653 * the node is async-capable, and an asynchronous fetch for it is still in
1654 * progress; if so, complete the asynchronous fetch before restarting the
1655 * scan.
1656 */
1662 /*
1663 * If any internal parameters affecting this node have changed, we'd
1664 * better destroy and recreate the cursor. Otherwise, rewinding it should
1665 * be good enough. If we've only fetched zero or one batch, we needn't
1666 * even rewind the cursor, just rescan what we have.
1667 */
1669 {
1673 }
1675 {
1678 }
1679 else
1680 {
1681 /* Easy: just rescan what we already have in memory, if anything */
1684 }
1686 /*
1687 * We don't use a PG_TRY block here, so be careful not to throw error
1688 * without releasing the PGresult.
1689 */
1695 /* Now force a fresh FETCH. */
1701 }
1703 /*
1704 * postgresEndForeignScan
1705 * Finish scanning foreign table and dispose objects used for this scan
1706 */
1707 static void
1709 {
1712 /* if fsstate is NULL, we are in EXPLAIN; nothing to do */
1716 /* Close the cursor if open, to prevent accumulation of cursors */
1721 /* Release remote connection */
1725 /* MemoryContexts will be deleted automatically. */
1726 }
1728 /*
1729 * postgresAddForeignUpdateTargets
1730 * Add resjunk column(s) needed for update/delete on a foreign table
1731 */
1732 static void
1734 Index rtindex,
1736 Relation target_relation)
1737 {
1740 /*
1741 * In postgres_fdw, what we need is the ctid, same as for a regular table.
1742 */
1744 /* Make a Var representing the desired value */
1746 SelfItemPointerAttributeNumber,
1747 TIDOID,
1749 InvalidOid,
1752 /* Register it as a row-identity column needed by this target rel */
1754 }
1756 /*
1757 * postgresPlanForeignModify
1758 * Plan an insert/update/delete operation on a foreign table
1759 */
1763 Index resultRelation,
1765 {
1768 Relation rel;
1769 StringInfoData sql;
1779 /*
1780 * Core code already has some lock on each rel being planned, so we can
1781 * use NoLock here.
1782 */
1785 /*
1786 * In an INSERT, we transmit all columns that are defined in the foreign
1787 * table. In an UPDATE, if there are BEFORE ROW UPDATE triggers on the
1788 * foreign table, we transmit all columns like INSERT; else we transmit
1789 * only columns that were explicitly targets of the UPDATE, so as to avoid
1790 * unnecessary data transmission. (We can't do that for INSERT since we
1791 * would miss sending default values for columns not listed in the source
1792 * statement, and for UPDATE if there are BEFORE ROW UPDATE triggers since
1793 * those triggers might change values for non-target columns, in which
1794 * case we would miss sending changed values for those columns.)
1795 */
1800 {
1805 {
1810 }
1811 }
1813 {
1820 {
1821 /* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
1827 }
1828 }
1830 /*
1831 * Extract the relevant WITH CHECK OPTION list if any.
1832 */
1835 subplan_index);
1837 /*
1838 * Extract the relevant RETURNING list if any.
1839 */
1843 /*
1844 * ON CONFLICT DO UPDATE and DO NOTHING case with inference specification
1845 * should have already been rejected in the optimizer, as presently there
1846 * is no way to recognize an arbiter index on a foreign table. Only DO
1847 * NOTHING is supported without an inference specification.
1848 */
1855 /*
1856 * Construct the SQL command string.
1857 */
1859 {
1868 targetAttrs,
1874 returningList,
1880 }
1884 /*
1885 * Build the fdw_private list that will be available to the executor.
1886 * Items in the list must match enum FdwModifyPrivateIndex, above.
1887 */
1889 targetAttrs,
1892 retrieved_attrs);
1893 }
1895 /*
1896 * postgresBeginForeignModify
1897 * Begin an insert/update/delete operation on a foreign table
1898 */
1899 static void
1905 {
1914 /*
1915 * Do nothing in EXPLAIN (no ANALYZE) case. resultRelInfo->ri_FdwState
1916 * stays NULL.
1917 */
1921 /* Deconstruct fdw_private data. */
1923 FdwModifyPrivateUpdateSql));
1925 FdwModifyPrivateTargetAttnums);
1927 FdwModifyPrivateLen));
1929 FdwModifyPrivateHasReturning));
1931 FdwModifyPrivateRetrievedAttrs);
1933 /* Find RTE. */
1937 /* Construct an execution state. */
1939 rte,
1940 resultRelInfo,
1943 query,
1944 target_attrs,
1945 values_end_len,
1946 has_returning,
1947 retrieved_attrs);
1950 }
1952 /*
1953 * postgresExecForeignInsert
1954 * Insert one row into a foreign table
1955 */
1961 {
1966 /*
1967 * If the fmstate has aux_fmstate set, use the aux_fmstate (see
1968 * postgresBeginForeignInsert())
1969 */
1974 /* Revert that change */
1979 }
1981 /*
1982 * postgresExecForeignBatchInsert
1983 * Insert multiple rows into a foreign table
1984 */
1991 {
1995 /*
1996 * If the fmstate has aux_fmstate set, use the aux_fmstate (see
1997 * postgresBeginForeignInsert())
1998 */
2003 /* Revert that change */
2008 }
2010 /*
2011 * postgresGetForeignModifyBatchSize
2012 * Determine the maximum number of tuples that can be inserted in bulk
2013 *
2014 * Returns the batch size specified for server or table. When batching is not
2015 * allowed (e.g. for tables with BEFORE/AFTER ROW triggers or with RETURNING
2016 * clause), returns 1.
2017 */
2018 static int
2020 {
2024 /* should be called only once */
2027 /*
2028 * Should never get called when the insert is being performed on a table
2029 * that is also among the target relations of an UPDATE operation, because
2030 * postgresBeginForeignInsert() currently rejects such insert attempts.
2031 */
2034 /*
2035 * In EXPLAIN without ANALYZE, ri_FdwState is NULL, so we have to lookup
2036 * the option directly in server/table options. Otherwise just use the
2037 * value we determined earlier.
2038 */
2041 else
2044 /*
2045 * Disable batching when we have to use RETURNING, there are any
2046 * BEFORE/AFTER ROW INSERT triggers on the foreign table, or there are any
2047 * WITH CHECK OPTION constraints from parent views.
2048 *
2049 * When there are any BEFORE ROW INSERT triggers on the table, we can't
2050 * support it, because such triggers might query the table we're inserting
2051 * into and act differently if the tuples that have already been processed
2052 * and prepared for insertion are not there.
2053 */
2061 /*
2062 * If the foreign table has no columns, disable batching as the INSERT
2063 * syntax doesn't allow batching multiple empty rows into a zero-column
2064 * table in a single statement. This is needed for COPY FROM, in which
2065 * case fmstate must be non-NULL.
2066 */
2070 /*
2071 * Otherwise use the batch size specified for server/table. The number of
2072 * parameters in a batch is limited to 65535 (uint16), so make sure we
2073 * don't exceed this limit by using the maximum batch_size possible.
2074 */
2079 }
2081 /*
2082 * postgresExecForeignUpdate
2083 * Update one row in a foreign table
2084 */
2090 {
2098 }
2100 /*
2101 * postgresExecForeignDelete
2102 * Delete one row from a foreign table
2103 */
2109 {
2117 }
2119 /*
2120 * postgresEndForeignModify
2121 * Finish an insert/update/delete operation on a foreign table
2122 */
2123 static void
2126 {
2129 /* If fmstate is NULL, we are in EXPLAIN; nothing to do */
2133 /* Destroy the execution state */
2135 }
2137 /*
2138 * postgresBeginForeignInsert
2139 * Begin an insert operation on a foreign table
2140 */
2141 static void
2144 {
2148 Index resultRelation;
2154 StringInfoData sql;
2159 /*
2160 * If the foreign table we are about to insert routed rows into is also an
2161 * UPDATE subplan result rel that will be updated later, proceeding with
2162 * the INSERT will result in the later UPDATE incorrectly modifying those
2163 * routed rows, so prevent the INSERT --- it would be nice if we could
2164 * handle this case; but for now, throw an error for safety.
2165 */
2176 /* We transmit all columns that are defined in the foreign table. */
2178 {
2183 }
2185 /* Check if we add the ON CONFLICT clause to the remote query. */
2187 {
2190 /* We only support DO NOTHING without an inference specification. */
2196 }
2198 /*
2199 * If the foreign table is a partition that doesn't have a corresponding
2200 * RTE entry, we need to create a new RTE describing the foreign table for
2201 * use by deparseInsertSql and create_foreign_modify() below, after first
2202 * copying the parent's RTE and modifying some fields to describe the
2203 * foreign partition to work on. However, if this is invoked by UPDATE,
2204 * the existing RTE may already correspond to this partition if it is one
2205 * of the UPDATE subplan target rels; in that case, we can just use the
2206 * existing RTE as-is.
2207 */
2209 {
2217 /*
2218 * For UPDATE, we must use the RT index of the first subplan target
2219 * rel's RTE, because the core code would have built expressions for
2220 * the partition, such as RETURNING, using that RT index as varno of
2221 * Vars contained in those expressions.
2222 */
2226 else
2228 }
2229 else
2230 {
2233 }
2235 /* Construct the SQL command string. */
2241 /* Construct an execution state. */
2243 rte,
2244 resultRelInfo,
2245 CMD_INSERT,
2246 NULL,
2248 targetAttrs,
2249 values_end_len,
2251 retrieved_attrs);
2253 /*
2254 * If the given resultRelInfo already has PgFdwModifyState set, it means
2255 * the foreign table is an UPDATE subplan result rel; in which case, store
2256 * the resulting state into the aux_fmstate of the PgFdwModifyState.
2257 */
2259 {
2263 }
2264 else
2266 }
2268 /*
2269 * postgresEndForeignInsert
2270 * Finish an insert operation on a foreign table
2271 */
2272 static void
2275 {
2280 /*
2281 * If the fmstate has aux_fmstate set, get the aux_fmstate (see
2282 * postgresBeginForeignInsert())
2283 */
2287 /* Destroy the execution state */
2289 }
2291 /*
2292 * postgresIsForeignRelUpdatable
2293 * Determine whether a foreign table supports INSERT, UPDATE and/or
2294 * DELETE.
2295 */
2296 static int
2298 {
2304 /*
2305 * By default, all postgres_fdw foreign tables are assumed updatable. This
2306 * can be overridden by a per-server setting, which in turn can be
2307 * overridden by a per-table setting.
2308 */
2315 {
2320 }
2322 {
2327 }
2329 /*
2330 * Currently "updatable" means support for INSERT, UPDATE and DELETE.
2331 */
2334 }
2336 /*
2337 * postgresRecheckForeignScan
2338 * Execute a local join execution plan for a foreign join
2339 */
2340 static bool
2342 {
2347 /* For base foreign relations, it suffices to set fdw_recheck_quals */
2353 /* Execute a local join execution plan */
2358 /* Store result in the given slot */
2362 }
2364 /*
2365 * find_modifytable_subplan
2366 * Helper routine for postgresPlanDirectModify to find the
2367 * ModifyTable subplan node that scans the specified RTI.
2368 *
2369 * Returns NULL if the subplan couldn't be identified. That's not a fatal
2370 * error condition, we just abandon trying to do the update directly.
2371 */
2375 Index rtindex,
2377 {
2380 /*
2381 * The cases we support are (1) the desired ForeignScan is the immediate
2382 * child of ModifyTable, or (2) it is the subplan_index'th child of an
2383 * Append node that is the immediate child of ModifyTable. There is no
2384 * point in looking further down, as that would mean that local joins are
2385 * involved, so we can't do the update directly.
2386 *
2387 * There could be a Result atop the Append too, acting to compute the
2388 * UPDATE targetlist values. We ignore that here; the tlist will be
2389 * checked by our caller.
2390 *
2391 * In principle we could examine all the children of the Append, but it's
2392 * currently unlikely that the core planner would generate such a plan
2393 * with the children out-of-order. Moreover, such a search risks costing
2394 * O(N^2) time when there are a lot of children.
2395 */
2397 {
2402 }
2406 {
2411 }
2413 /* Now, have we got a ForeignScan on the desired rel? */
2415 {
2420 }
2423 }
2425 /*
2426 * postgresPlanDirectModify
2427 * Consider a direct foreign table modification
2428 *
2429 * Decide whether it is safe to modify a foreign table directly, and if so,
2430 * rewrite subplan accordingly.
2431 */
2432 static bool
2435 Index resultRelation,
2437 {
2442 Relation rel;
2443 StringInfoData sql;
2452 /*
2453 * Decide whether it is safe to modify a foreign table directly.
2454 */
2456 /*
2457 * The table modification must be an UPDATE or DELETE.
2458 */
2462 /*
2463 * Try to locate the ForeignScan subplan that's scanning resultRelation.
2464 */
2469 /*
2470 * It's unsafe to modify a foreign table directly if there are any quals
2471 * that should be evaluated locally.
2472 */
2476 /* Safe to fetch data about the target foreign rel */
2478 {
2480 /* We should have a rel for this foreign join. */
2482 }
2483 else
2488 /*
2489 * It's unsafe to update a foreign table directly, if any expressions to
2490 * assign to the target columns are unsafe to evaluate remotely.
2491 */
2493 {
2497 /*
2498 * The expressions of concern are the first N columns of the processed
2499 * targetlist, where N is the length of the rel's update_colnos.
2500 */
2504 {
2508 /* update's new-value expressions shouldn't be resjunk */
2516 }
2517 }
2519 /*
2520 * Ok, rewrite subplan so as to modify the foreign table directly.
2521 */
2524 /*
2525 * Core code already has some lock on each rel being planned, so we can
2526 * use NoLock here.
2527 */
2530 /*
2531 * Recall the qual clauses that must be evaluated remotely. (These are
2532 * bare clauses not RestrictInfos, but deparse.c's appendConditions()
2533 * doesn't care.)
2534 */
2537 /*
2538 * Extract the relevant RETURNING list if any.
2539 */
2541 {
2544 /*
2545 * When performing an UPDATE/DELETE .. RETURNING on a join directly,
2546 * we fetch from the foreign server any Vars specified in RETURNING
2547 * that refer not only to the target relation but to non-target
2548 * relations. So we'll deparse them into the RETURNING clause of the
2549 * remote query; use a targetlist consisting of them instead, which
2550 * will be adjusted to be new fdw_scan_tlist of the foreign-scan plan
2551 * node below.
2552 */
2555 returningList);
2556 }
2558 /*
2559 * Construct the SQL command string.
2560 */
2562 {
2565 foreignrel,
2566 processed_tlist,
2567 targetAttrs,
2573 foreignrel,
2580 }
2582 /*
2583 * Update the operation and target relation info.
2584 */
2588 /*
2589 * Update the fdw_exprs list that will be available to the executor.
2590 */
2593 /*
2594 * Update the fdw_private list that will be available to the executor.
2595 * Items in the list must match enum FdwDirectModifyPrivateIndex, above.
2596 */
2599 retrieved_attrs,
2602 /*
2603 * Update the foreign-join-related fields.
2604 */
2606 {
2607 /* No need for the outer subplan. */
2610 /* Build new fdw_scan_tlist if UPDATE/DELETE .. RETURNING. */
2613 }
2615 /*
2616 * Finally, unset the async-capable flag if it is set, as we currently
2617 * don't support asynchronous execution of direct modifications.
2618 */
2624 }
2626 /*
2627 * postgresBeginDirectModify
2628 * Prepare a direct foreign table modification
2629 */
2630 static void
2632 {
2636 Index rtindex;
2637 Oid userid;
2642 /*
2643 * Do nothing in EXPLAIN (no ANALYZE) case. node->fdw_state stays NULL.
2644 */
2648 /*
2649 * We'll save private state in node->fdw_state.
2650 */
2654 /*
2655 * Identify which user to do the remote access as. This should match what
2656 * ExecCheckPermissions() does.
2657 */
2660 /* Get info about foreign table. */
2664 else
2669 /*
2670 * Get connection to the foreign server. Connection manager will
2671 * establish new connection if necessary.
2672 */
2675 /* Update the foreign-join-related fields. */
2677 {
2678 /* Save info about foreign table. */
2681 /*
2682 * Set dmstate->rel to NULL to teach get_returning_data() and
2683 * make_tuple_from_result_row() that columns fetched from the remote
2684 * server are described by fdw_scan_tlist of the foreign-scan plan
2685 * node, not the tuple descriptor for the target relation.
2686 */
2688 }
2690 /* Initialize state variable */
2693 /* Get private info created by planner functions. */
2695 FdwDirectModifyPrivateUpdateSql));
2697 FdwDirectModifyPrivateHasReturning));
2699 FdwDirectModifyPrivateRetrievedAttrs);
2701 FdwDirectModifyPrivateSetProcessed));
2703 /* Create context for per-tuple temp workspace. */
2706 ALLOCSET_SMALL_SIZES);
2708 /* Prepare for input conversion of RETURNING results. */
2710 {
2711 TupleDesc tupdesc;
2715 else
2720 /*
2721 * When performing an UPDATE/DELETE .. RETURNING on a join directly,
2722 * initialize a filter to extract an updated/deleted tuple from a scan
2723 * tuple.
2724 */
2727 }
2729 /*
2730 * Prepare for processing of parameters used in remote query, if any.
2731 */
2737 numParams,
2741 }
2743 /*
2744 * postgresIterateDirectModify
2745 * Execute a direct foreign table modification
2746 */
2749 {
2754 /*
2755 * If this is the first call after Begin, execute the statement.
2756 */
2760 /*
2761 * If the local query doesn't specify RETURNING, just clear tuple slot.
2762 */
2764 {
2770 /* Increment the command es_processed count if necessary. */
2774 /* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
2779 }
2781 /*
2782 * Get the next RETURNING tuple.
2783 */
2785 }
2787 /*
2788 * postgresEndDirectModify
2789 * Finish a direct foreign table modification
2790 */
2791 static void
2793 {
2796 /* if dmstate is NULL, we are in EXPLAIN; nothing to do */
2800 /* Release PGresult */
2803 /* Release remote connection */
2807 /* MemoryContext will be deleted automatically. */
2808 }
2810 /*
2811 * postgresExplainForeignScan
2812 * Produce extra output for EXPLAIN of a ForeignScan on a foreign table
2813 */
2814 static void
2816 {
2820 /*
2821 * Identify foreign scans that are really joins or upper relations. The
2822 * input looks something like "(1) LEFT JOIN (2)", and we must replace the
2823 * digit string(s), which are RT indexes, with the correct relation names.
2824 * We do that here, not when the plan is created, because we can't know
2825 * what aliases ruleutils.c will assign at plan creation time.
2826 */
2828 {
2829 StringInfo relations;
2833 rtoffset;
2837 /*
2838 * A difficulty with using a string representation of RT indexes is
2839 * that setrefs.c won't update the string when flattening the
2840 * rangetable. To find out what rtoffset was applied, identify the
2841 * minimum RT index appearing in the string and compare it to the
2842 * minimum member of plan->fs_base_relids. (We expect all the relids
2843 * in the join will have been offset by the same amount; the Asserts
2844 * below should catch it if that ever changes.)
2845 */
2849 {
2851 {
2856 }
2857 else
2858 ptr++;
2859 }
2862 /* Now we can translate the string */
2866 {
2868 {
2878 /* This logic should agree with explain.c's ExplainTargetRel */
2881 {
2888 }
2889 else
2898 }
2899 else
2901 }
2903 }
2905 /*
2906 * Add remote query, when VERBOSE option is specified.
2907 */
2909 {
2914 }
2915 }
2917 /*
2918 * postgresExplainForeignModify
2919 * Produce extra output for EXPLAIN of a ModifyTable on a foreign table
2920 */
2921 static void
2927 {
2929 {
2931 FdwModifyPrivateUpdateSql));
2935 /*
2936 * For INSERT we should always have batch size >= 1, but UPDATE and
2937 * DELETE don't support batching so don't show the property.
2938 */
2941 }
2942 }
2944 /*
2945 * postgresExplainDirectModify
2946 * Produce extra output for EXPLAIN of a ForeignScan that modifies a
2947 * foreign table directly
2948 */
2949 static void
2951 {
2956 {
2960 }
2961 }
2963 /*
2964 * postgresExecForeignTruncate
2965 * Truncate one or more foreign tables
2966 */
2967 static void
2969 DropBehavior behavior,
2971 {
2975 StringInfoData sql;
2979 /*
2980 * By default, all postgres_fdw foreign tables are assumed truncatable.
2981 * This can be overridden by a per-server setting, which in turn can be
2982 * overridden by a per-table setting.
2983 */
2985 {
2992 /*
2993 * First time through, determine whether the foreign server allows
2994 * truncates. Since all specified foreign tables are assumed to belong
2995 * to the same foreign server, this result can be used for other
2996 * foreign tables.
2997 */
2999 {
3004 {
3008 {
3011 }
3012 }
3013 }
3015 /*
3016 * Confirm that all specified foreign tables belong to the same
3017 * foreign server.
3018 */
3021 /* Determine whether this foreign table allows truncations */
3024 {
3028 {
3031 }
3032 }
3039 }
3042 /*
3043 * Get connection to the foreign server. Connection manager will
3044 * establish new connection if necessary.
3045 */
3049 /* Construct the TRUNCATE command string */
3053 /* Issue the TRUNCATE command to remote server */
3057 }
3059 /*
3060 * estimate_path_cost_size
3061 * Get cost and size estimates for a foreign scan on given foreign relation
3062 * either a base relation or a join between foreign relations or an upper
3063 * relation containing foreign relations.
3064 *
3065 * param_join_conds are the parameterization clauses with outer relations.
3066 * pathkeys specify the expected sort order if any for given path being costed.
3067 * fpextra specifies additional post-scan/join-processing steps such as the
3068 * final sort and the LIMIT restriction.
3069 *
3070 * The function returns the cost and size estimates in p_rows, p_width,
3071 * p_startup_cost and p_total_cost variables.
3072 */
3073 static void
3081 {
3086 Cost startup_cost;
3087 Cost total_cost;
3089 /* Make sure the core code has set up the relation's reltarget */
3092 /*
3093 * If the table or the server is configured to use remote estimates,
3094 * connect to the foreign server and execute EXPLAIN to estimate the
3095 * number of rows selected by the restriction+join clauses. Otherwise,
3096 * estimate rows using whatever statistics we have locally, in a way
3097 * similar to ordinary tables.
3098 */
3100 {
3103 StringInfoData sql;
3105 Selectivity local_sel;
3106 QualCost local_cost;
3110 /* Required only to be passed to deparseSelectStmtForRel */
3113 /*
3114 * param_join_conds might contain both clauses that are safe to send
3115 * across, and clauses that aren't.
3116 */
3120 /* Build the list of columns to be fetched from the foreign server. */
3123 else
3126 /*
3127 * The complete list of remote conditions includes everything from
3128 * baserestrictinfo plus any extra join_conds relevant to this
3129 * particular path.
3130 */
3134 /*
3135 * Construct EXPLAIN query including the desired SELECT, FROM, and
3136 * WHERE clauses. Params and other-relation Vars are replaced by dummy
3137 * values, so don't request params_list.
3138 */
3147 /* Get the remote estimate */
3155 /* Factor in the selectivity of the locally-checked quals */
3157 local_param_join_conds,
3159 JOIN_INNER,
3160 NULL);
3165 /* Add in the eval cost of the locally-checked quals */
3172 /*
3173 * Add in tlist eval cost for each output row. In case of an
3174 * aggregate, some of the tlist expressions such as grouping
3175 * expressions will be evaluated remotely, so adjust the costs.
3176 */
3181 {
3182 QualCost tlist_cost;
3188 }
3189 }
3190 else
3191 {
3194 /*
3195 * We don't support join conditions in this mode (hence, no
3196 * parameterized paths can be made).
3197 */
3200 /*
3201 * We will come here again and again with different set of pathkeys or
3202 * additional post-scan/join-processing steps that caller wants to
3203 * cost. We don't need to calculate the cost/size estimates for the
3204 * underlying scan, join, or grouping each time. Instead, use those
3205 * estimates if we have cached them already.
3206 */
3208 {
3217 /*
3218 * If we estimate the costs of a foreign scan or a foreign join
3219 * with additional post-scan/join-processing steps, the scan or
3220 * join costs obtained from the cache wouldn't yet contain the
3221 * eval costs for the final scan/join target, which would've been
3222 * updated by apply_scanjoin_target_to_paths(); add the eval costs
3223 * now.
3224 */
3226 {
3227 /* Shouldn't get here unless we have LIMIT */
3233 }
3234 }
3236 {
3239 QualCost join_cost;
3240 QualCost remote_conds_cost;
3243 /* Use rows/width estimates made by the core code. */
3247 /* For join we expect inner and outer relations set */
3253 /* Estimate of number of rows in cross product */
3256 /*
3257 * Back into an estimate of the number of retrieved rows. Just in
3258 * case this is nuts, clamp to at most nrows.
3259 */
3263 /*
3264 * The cost of foreign join is estimated as cost of generating
3265 * rows for the joining relations + cost for applying quals on the
3266 * rows.
3267 */
3269 /*
3270 * Calculate the cost of clauses pushed down to the foreign server
3271 */
3273 /* Calculate the cost of applying join clauses */
3276 /*
3277 * Startup cost includes startup cost of joining relations and the
3278 * startup cost for join and other clauses. We do not include the
3279 * startup cost specific to join strategy (e.g. setting up hash
3280 * tables) since we do not know what strategy the foreign server
3281 * is going to use.
3282 */
3288 /*
3289 * Run time cost includes:
3290 *
3291 * 1. Run time cost (total_cost - startup_cost) of relations being
3292 * joined
3293 *
3294 * 2. Run time cost of applying join clauses on the cross product
3295 * of the joining relations.
3296 *
3297 * 3. Run time cost of applying pushed down other clauses on the
3298 * result of join
3299 *
3300 * 4. Run time cost of applying nonpushable other clauses locally
3301 * on the result fetched from the foreign server.
3302 */
3310 /* Add in tlist eval cost for each output row */
3313 }
3315 {
3318 AggClauseCosts aggcosts;
3323 /* The upper relation should have its outer relation set */
3325 /* and that outer relation should have its reltarget set */
3328 /*
3329 * This cost model is mixture of costing done for sorted and
3330 * hashed aggregates in cost_agg(). We are not sure which
3331 * strategy will be considered at remote side, thus for
3332 * simplicity, we put all startup related costs in startup_cost
3333 * and all finalization and run cost are added in total_cost.
3334 */
3338 /* Get rows from input rel */
3341 /* Collect statistics about aggregates for estimating costs. */
3344 {
3346 }
3348 /* Get number of grouping columns and possible number of groups */
3355 /*
3356 * Get the retrieved_rows and rows estimates. If there are HAVING
3357 * quals, account for their selectivity.
3358 */
3360 {
3361 /* Factor in the selectivity of the remotely-checked quals */
3362 retrieved_rows =
3367 JOIN_INNER,
3368 NULL));
3369 /* Factor in the selectivity of the locally-checked quals */
3371 }
3372 else
3373 {
3375 }
3377 /* Use width estimate made by the core code. */
3380 /*-----
3381 * Startup cost includes:
3382 * 1. Startup cost for underneath input relation, adjusted for
3383 * tlist replacement by apply_scanjoin_target_to_paths()
3384 * 2. Cost of performing aggregation, per cost_agg()
3385 *-----
3386 */
3394 /*-----
3395 * Run time cost includes:
3396 * 1. Run time cost of underneath input relation, adjusted for
3397 * tlist replacement by apply_scanjoin_target_to_paths()
3398 * 2. Run time cost of performing aggregation, per cost_agg()
3399 *-----
3400 */
3406 /* Account for the eval cost of HAVING quals, if any */
3408 {
3409 QualCost remote_cost;
3411 /* Add in the eval cost of the remotely-checked quals */
3415 /* Add in the eval cost of the locally-checked quals */
3418 }
3420 /* Add in tlist eval cost for each output row */
3423 }
3424 else
3425 {
3426 Cost cpu_per_tuple;
3428 /* Use rows/width estimates made by set_baserel_size_estimates. */
3432 /*
3433 * Back into an estimate of the number of retrieved rows. Just in
3434 * case this is nuts, clamp to at most foreignrel->tuples.
3435 */
3439 /*
3440 * Cost as though this were a seqscan, which is pessimistic. We
3441 * effectively imagine the local_conds are being evaluated
3442 * remotely, too.
3443 */
3452 /* Add in tlist eval cost for each output row */
3455 }
3457 /*
3458 * Without remote estimates, we have no real way to estimate the cost
3459 * of generating sorted output. It could be free if the query plan
3460 * the remote side would have chosen generates properly-sorted output
3461 * anyway, but in most cases it will cost something. Estimate a value
3462 * high enough that we won't pick the sorted path when the ordering
3463 * isn't locally useful, but low enough that we'll err on the side of
3464 * pushing down the ORDER BY clause when it's useful to do so.
3465 */
3467 {
3469 {
3476 }
3477 else
3478 {
3481 }
3482 }
3486 /* Adjust the cost estimates if we have LIMIT */
3488 {
3492 }
3493 }
3495 /*
3496 * If this includes the final sort step, the given target, which will be
3497 * applied to the resulting path, might have different expressions from
3498 * the foreignrel's reltarget (see make_sort_input_target()); adjust tlist
3499 * eval costs.
3500 */
3503 {
3510 }
3512 /*
3513 * Cache the retrieved rows and cost estimates for scans, joins, or
3514 * groupings without any parameterization, pathkeys, or additional
3515 * post-scan/join-processing steps, before adding the costs for
3516 * transferring data from the foreign server. These estimates are useful
3517 * for costing remote joins involving this relation or costing other
3518 * remote operations on this relation such as remote sorts and remote
3519 * LIMIT restrictions, when the costs can not be obtained from the foreign
3520 * server. This function will be called at least once for every foreign
3521 * relation without any parameterization, pathkeys, or additional
3522 * post-scan/join-processing steps.
3523 */
3525 {
3529 }
3531 /*
3532 * Add some additional cost factors to account for connection overhead
3533 * (fdw_startup_cost), transferring data across the network
3534 * (fdw_tuple_cost per retrieved row), and local manipulation of the data
3535 * (cpu_tuple_cost per retrieved row).
3536 */
3542 /*
3543 * If we have LIMIT, we should prefer performing the restriction remotely
3544 * rather than locally, as the former avoids extra row fetches from the
3545 * remote that the latter might cause. But since the core code doesn't
3546 * account for such fetches when estimating the costs of the local
3547 * restriction (see create_limit_path()), there would be no difference
3548 * between the costs of the local restriction and the costs of the remote
3549 * restriction estimated above if we don't use remote estimates (except
3550 * for the case where the foreignrel is a grouping relation, the given
3551 * pathkeys is not NIL, and the effects of a bounded sort for that rel is
3552 * accounted for in costing the remote restriction). Tweak the costs of
3553 * the remote restriction to ensure we'll prefer it if LIMIT is a useful
3554 * one.
3555 */
3560 {
3564 }
3566 /* Return results. */
3571 }
3573 /*
3574 * Estimate costs of executing a SQL statement remotely.
3575 * The given "sql" must be an EXPLAIN command.
3576 */
3577 static void
3581 {
3584 /* PGresult must be released before leaving this function. */
3586 {
3591 /*
3592 * Execute EXPLAIN remotely.
3593 */
3598 /*
3599 * Extract cost numbers for topmost plan node. Note we search for a
3600 * left paren from the end of the line to avoid being confused by
3601 * other uses of parentheses.
3602 */
3611 }
3613 {
3615 }
3617 }
3619 /*
3620 * Adjust the cost estimates of a foreign grouping path to include the cost of
3621 * generating properly-sorted output.
3622 */
3623 static void
3631 {
3632 /*
3633 * If the GROUP BY clause isn't sort-able, the plan chosen by the remote
3634 * side is unlikely to generate properly-sorted output, so it would need
3635 * an explicit sort; adjust the given costs with cost_sort(). Likewise,
3636 * if the GROUP BY clause is sort-able but isn't a superset of the given
3637 * pathkeys, adjust the costs with that function. Otherwise, adjust the
3638 * costs by applying the same heuristic as for the scan or join case.
3639 */
3642 {
3646 root,
3647 pathkeys,
3649 retrieved_rows,
3650 width,
3652 work_mem,
3653 limit_tuples);
3657 }
3658 else
3659 {
3660 /*
3661 * The default extra cost seems too large for foreign-grouping cases;
3662 * add 1/4th of that default.
3663 */
3669 }
3670 }
3672 /*
3673 * Detect whether we want to process an EquivalenceClass member.
3674 *
3675 * This is a callback for use by generate_implied_equalities_for_column.
3676 */
3677 static bool
3681 {
3685 /*
3686 * If we've identified what we're processing in the current scan, we only
3687 * want to match that expression.
3688 */
3692 /*
3693 * Otherwise, ignore anything we've already processed.
3694 */
3698 /* This is the new target to process. */
3701 }
3703 /*
3704 * Create cursor for node's query with current parameter values.
3705 */
3706 static void
3708 {
3714 StringInfoData buf;
3717 /* First, process a pending asynchronous request, if any. */
3721 /*
3722 * Construct array of query parameter values in text format. We do the
3723 * conversions in the short-lived per-tuple context, so as not to cause a
3724 * memory leak over repeated scans.
3725 */
3727 {
3728 MemoryContext oldcontext;
3735 values);
3738 }
3740 /* Construct the DECLARE CURSOR command */
3745 /*
3746 * Notice that we pass NULL for paramTypes, thus forcing the remote server
3747 * to infer types for all parameters. Since we explicitly cast every
3748 * parameter (see deparse.c), the "inference" is trivial and will produce
3749 * the desired result. This allows us to avoid assuming that the remote
3750 * server has the same OIDs we do for the parameters' types.
3751 */
3756 /*
3757 * Get the result, and check for success.
3758 *
3759 * We don't use a PG_TRY block here, so be careful not to throw error
3760 * without releasing the PGresult.
3761 */
3767 /* Mark the cursor as created, and show no tuples have been retrieved */
3775 /* Clean up */
3777 }
3779 /*
3780 * Fetch some more rows from the node's cursor.
3781 */
3782 static void
3784 {
3787 MemoryContext oldcontext;
3789 /*
3790 * We'll store the tuples in the batch_cxt. First, flush the previous
3791 * batch.
3792 */
3797 /* PGresult must be released before leaving this function. */
3799 {
3805 {
3808 /*
3809 * The query was already sent by an earlier call to
3810 * fetch_more_data_begin. So now we just fetch the result.
3811 */
3813 /* On error, report the original query, not the FETCH. */
3817 /* Reset per-connection state */
3819 }
3820 else
3821 {
3824 /* This is a regular synchronous fetch. */
3829 /* On error, report the original query, not the FETCH. */
3832 }
3834 /* Convert the data into HeapTuples */
3841 {
3849 node,
3851 }
3853 /* Update fetch_ct_2 */
3857 /* Must be EOF if we didn't get as many tuples as we asked for. */
3859 }
3861 {
3863 }
3867 }
3869 /*
3870 * Force assorted GUC parameters to settings that ensure that we'll output
3871 * data values in a form that is unambiguous to the remote server.
3872 *
3873 * This is rather expensive and annoying to do once per row, but there's
3874 * little choice if we want to be sure values are transmitted accurately;
3875 * we can't leave the settings in place between rows for fear of affecting
3876 * user-visible computations.
3877 *
3878 * We use the equivalent of a function SET option to allow the settings to
3879 * persist only until the caller calls reset_transmission_modes(). If an
3880 * error is thrown in between, guc.c will take care of undoing the settings.
3881 *
3882 * The return value is the nestlevel that must be passed to
3883 * reset_transmission_modes() to undo things.
3884 */
3885 int
3887 {
3890 /*
3891 * The values set here should match what pg_dump does. See also
3892 * configure_remote_session in connection.c.
3893 */
3907 /*
3908 * In addition force restrictive search_path, in case there are any
3909 * regproc or similar constants to be printed.
3910 */
3916 }
3918 /*
3919 * Undo the effects of set_transmission_modes().
3920 */
3921 void
3923 {
3925 }
3927 /*
3928 * Utility routine to close a cursor.
3929 */
3930 static void
3933 {
3939 /*
3940 * We don't use a PG_TRY block here, so be careful not to throw error
3941 * without releasing the PGresult.
3942 */
3947 }
3949 /*
3950 * create_foreign_modify
3951 * Construct an execution state of a foreign insert/update/delete
3952 * operation
3953 */
3958 CmdType operation,
3965 {
3969 Oid userid;
3972 AttrNumber n_params;
3973 Oid typefnoid;
3977 /* Begin constructing PgFdwModifyState. */
3981 /* Identify which user to do the remote access as. */
3984 /* Get info about foreign table. */
3988 /* Open connection; report that we'll create a prepared statement. */
3992 /* Set up remote query information. */
3995 {
3998 }
4004 /* Create context for per-tuple temp workspace. */
4007 ALLOCSET_SMALL_SIZES);
4009 /* Prepare for input conversion of RETURNING results. */
4013 /* Prepare for output conversion of parameters used in prepared stmt. */
4019 {
4022 /* Find the ctid resjunk column in the subplan's result */
4028 /* First transmittable parameter will be ctid */
4032 }
4035 {
4036 /* Set up for remaining transmittable parameters */
4038 {
4044 /* Ignore generated columns; they are set to DEFAULT */
4050 }
4051 }
4055 /* Set batch_size from foreign server/table options. */
4061 /* Initialize auxiliary state */
4065 }
4067 /*
4068 * execute_foreign_modify
4069 * Perform foreign-table modification as required, and fetch RETURNING
4070 * result if any. (This is the shared guts of postgresExecForeignInsert,
4071 * postgresExecForeignBatchInsert, postgresExecForeignUpdate, and
4072 * postgresExecForeignDelete.)
4073 */
4077 CmdType operation,
4081 {
4087 StringInfoData sql;
4089 /* The operation should be INSERT, UPDATE, or DELETE */
4094 /* First, process a pending asynchronous request, if any. */
4098 /*
4099 * If the existing query was deparsed and prepared for a different number
4100 * of rows, rebuild it for the proper number.
4101 */
4103 {
4104 /* Destroy the prepared statement created previously */
4108 /* Build INSERT string with numSlots records in its VALUES clause. */
4117 }
4119 /* Set up the prepared statement on the remote server, if we didn't yet */
4123 /*
4124 * For UPDATE/DELETE, get the ctid that was passed up as a resjunk column
4125 */
4127 {
4128 Datum datum;
4134 /* shouldn't ever get a null result... */
4138 }
4140 /* Convert parameters needed by prepared statement to text form */
4143 /*
4144 * Execute the prepared statement.
4145 */
4149 p_values,
4150 NULL,
4151 NULL,
4155 /*
4156 * Get the result, and check for success.
4157 *
4158 * We don't use a PG_TRY block here, so be careful not to throw error
4159 * without releasing the PGresult.
4160 */
4166 /* Check number of rows affected, and fetch RETURNING tuple if any */
4168 {
4173 }
4174 else
4177 /* And clean up */
4184 /*
4185 * Return NULL if nothing was inserted/updated/deleted on the remote end
4186 */
4188 }
4190 /*
4191 * prepare_foreign_modify
4192 * Establish a prepared statement for execution of INSERT/UPDATE/DELETE
4193 */
4194 static void
4196 {
4201 /*
4202 * The caller would already have processed a pending asynchronous request
4203 * if any, so no need to do it here.
4204 */
4206 /* Construct name we'll use for the prepared statement. */
4211 /*
4212 * We intentionally do not specify parameter types here, but leave the
4213 * remote server to derive them by default. This avoids possible problems
4214 * with the remote server using different type OIDs than we do. All of
4215 * the prepared statements we use in this module are simple enough that
4216 * the remote server will make the right choices.
4217 */
4219 p_name,
4222 NULL))
4225 /*
4226 * Get the result, and check for success.
4227 *
4228 * We don't use a PG_TRY block here, so be careful not to throw error
4229 * without releasing the PGresult.
4230 */
4236 /* This action shows that the prepare has been done. */
4238 }
4240 /*
4241 * convert_prep_stmt_params
4242 * Create array of text strings representing parameter values
4243 *
4244 * tupleid is ctid to send, or NULL if none
4245 * slot is slot to get remaining parameters from, or NULL if none
4246 *
4247 * Data is constructed in temp_cxt; caller should reset that after use.
4248 */
4251 ItemPointer tupleid,
4254 {
4259 MemoryContext oldcontext;
4265 /* ctid is provided only for UPDATE/DELETE, which don't allow batching */
4268 /* 1st parameter should be ctid, if it's in use */
4270 {
4272 /* don't need set_transmission_modes for TID output */
4275 pindex++;
4276 }
4278 /* get following parameters from slots */
4280 {
4288 {
4291 {
4294 Datum value;
4297 /* Ignore generated columns; they are set to DEFAULT */
4303 else
4305 value);
4306 pindex++;
4307 j++;
4308 }
4309 }
4312 }
4319 }
4321 /*
4322 * store_returning_result
4323 * Store the result of a RETURNING clause
4324 *
4325 * On error, be sure to release the PGresult on the way out. Callers do not
4326 * have PG_TRY blocks to ensure this happens.
4327 */
4328 static void
4331 {
4333 {
4334 HeapTuple newtup;
4340 NULL,
4343 /*
4344 * The returning slot will not necessarily be suitable to store
4345 * heaptuples directly, so allow for conversion.
4346 */
4348 }
4350 {
4353 }
4355 }
4357 /*
4358 * finish_foreign_modify
4359 * Release resources for a foreign insert/update/delete operation
4360 */
4361 static void
4363 {
4366 /* If we created a prepared statement, destroy it */
4369 /* Release remote connection */
4372 }
4374 /*
4375 * deallocate_query
4376 * Deallocate a prepared statement for a foreign insert/update/delete
4377 * operation
4378 */
4379 static void
4381 {
4385 /* do nothing if the query is not allocated */
4391 /*
4392 * We don't use a PG_TRY block here, so be careful not to throw error
4393 * without releasing the PGresult.
4394 */
4401 }
4403 /*
4404 * build_remote_returning
4405 * Build a RETURNING targetlist of a remote query for performing an
4406 * UPDATE/DELETE .. RETURNING on a join directly
4407 */
4410 {
4420 /*
4421 * If there's a whole-row reference to the target relation, then we'll
4422 * need all the columns of the relation.
4423 */
4425 {
4431 {
4434 }
4435 }
4438 {
4443 {
4447 /* Ignore dropped attributes. */
4452 i,
4461 NULL,
4463 }
4464 }
4466 /* Now add any remaining columns to tlist. */
4468 {
4471 /*
4472 * No need for whole-row references to the target relation. We don't
4473 * need system columns other than ctid and oid either, since those are
4474 * set locally.
4475 */
4488 NULL,
4490 }
4495 }
4497 /*
4498 * rebuild_fdw_scan_tlist
4499 * Build new fdw_scan_tlist of given foreign-scan plan node from given
4500 * tlist
4501 *
4502 * There might be columns that the fdw_scan_tlist of the given foreign-scan
4503 * plan node contains that the given tlist doesn't. The fdw_scan_tlist would
4504 * have contained resjunk columns such as 'ctid' of the target relation and
4505 * 'wholerow' of non-target relations, but the tlist might not contain them,
4506 * for example. So, adjust the tlist so it contains all the columns specified
4507 * in the fdw_scan_tlist; else setrefs.c will get confused.
4508 */
4509 static void
4511 {
4517 {
4526 NULL,
4528 }
4530 }
4532 /*
4533 * Execute a direct UPDATE/DELETE statement.
4534 */
4535 static void
4537 {
4543 /* First, process a pending asynchronous request, if any. */
4547 /*
4548 * Construct array of query parameter values in text format.
4549 */
4554 values);
4556 /*
4557 * Notice that we pass NULL for paramTypes, thus forcing the remote server
4558 * to infer types for all parameters. Since we explicitly cast every
4559 * parameter (see deparse.c), the "inference" is trivial and will produce
4560 * the desired result. This allows us to avoid assuming that the remote
4561 * server has the same OIDs we do for the parameters' types.
4562 */
4567 /*
4568 * Get the result, and check for success.
4569 *
4570 * We don't use a PG_TRY block here, so be careful not to throw error
4571 * without releasing the PGresult.
4572 */
4579 /* Get the number of rows affected. */
4582 else
4584 }
4586 /*
4587 * Get the result of a RETURNING clause.
4588 */
4591 {
4600 /* If we didn't get any tuples, must be end of data. */
4604 /* Increment the command es_processed count if necessary. */
4608 /*
4609 * Store a RETURNING tuple. If has_returning is false, just emit a dummy
4610 * tuple. (has_returning is false when the local query is of the form
4611 * "UPDATE/DELETE .. RETURNING 1" for example.)
4612 */
4614 {
4617 }
4618 else
4619 {
4620 /*
4621 * On error, be sure to release the PGresult on the way out. Callers
4622 * do not have PG_TRY blocks to ensure this happens.
4623 */
4625 {
4626 HeapTuple newtup;
4633 node,
4636 }
4638 {
4641 }
4644 /* Get the updated/deleted tuple. */
4647 else
4649 }
4652 /* Make slot available for evaluation of the local query RETURNING list. */
4654 resultSlot;
4657 }
4659 /*
4660 * Initialize a filter to extract an updated/deleted tuple from a scan tuple.
4661 */
4662 static void
4665 Index rtindex)
4666 {
4671 /*
4672 * Calculate the mapping between the fdw_scan_tlist's entries and the
4673 * result tuple's attributes.
4674 *
4675 * The "map" is an array of indexes of the result tuple's attributes in
4676 * fdw_scan_tlist, i.e., one entry for every attribute of the result
4677 * tuple. We store zero for any attributes that don't have the
4678 * corresponding entries in that list, marking that a NULL is needed in
4679 * the result tuple.
4680 *
4681 * Also get the indexes of the entries for ctid and oid if any.
4682 */
4691 {
4697 /*
4698 * If the Var is a column of the target relation to be retrieved from
4699 * the foreign server, get the index of the entry.
4700 */
4703 {
4707 {
4708 /*
4709 * We don't retrieve system columns other than ctid and oid.
4710 */
4713 else
4716 }
4717 else
4718 {
4719 /*
4720 * We don't retrieve whole-row references to the target
4721 * relation either.
4722 */
4726 }
4727 }
4728 i++;
4729 }
4730 }
4732 /*
4733 * Extract and return an updated/deleted tuple from a scan tuple.
4734 */
4740 {
4749 /*
4750 * Use the return tuple slot as a place to store the result tuple.
4751 */
4754 /*
4755 * Extract all the values of the scan tuple.
4756 */
4761 /*
4762 * Prepare to build the result tuple.
4763 */
4768 /*
4769 * Transpose data into proper fields of the result tuple.
4770 */
4772 {
4776 {
4779 }
4780 else
4781 {
4784 }
4785 }
4787 /*
4788 * Build the virtual tuple.
4789 */
4792 /*
4793 * If we have any system columns to return, materialize a heap tuple in
4794 * the slot from column values set above and install system columns in
4795 * that tuple.
4796 */
4798 {
4801 /* ctid */
4803 {
4808 }
4810 /*
4811 * And remaining columns
4812 *
4813 * Note: since we currently don't allow the target relation to appear
4814 * on the nullable side of an outer join, any system columns wouldn't
4815 * go to NULL.
4816 *
4817 * Note: no need to care about tableoid here because it will be
4818 * initialized in ExecProcessReturning().
4819 */
4823 }
4825 /*
4826 * And return the result tuple.
4827 */
4829 }
4831 /*
4832 * Prepare for processing of parameters used in remote query.
4833 */
4834 static void
4841 {
4847 /* Prepare for output conversion of parameters used in remote query. */
4852 {
4854 Oid typefnoid;
4859 i++;
4860 }
4862 /*
4863 * Prepare remote-parameter expressions for evaluation. (Note: in
4864 * practice, we expect that all these expressions will be just Params, so
4865 * we could possibly do something more efficient than using the full
4866 * expression-eval machinery for this. But probably there would be little
4867 * benefit, and it'd require postgres_fdw to know more than is desirable
4868 * about Param evaluation.)
4869 */
4872 /* Allocate buffer for text form of query parameters. */
4874 }
4876 /*
4877 * Construct array of query parameter values in text format.
4878 */
4879 static void
4884 {
4893 {
4895 Datum expr_value;
4898 /* Evaluate the parameter expression */
4901 /*
4902 * Get string representation of each parameter value by invoking
4903 * type-specific output function, unless the value is null.
4904 */
4907 else
4910 i++;
4911 }
4914 }
4916 /*
4917 * postgresAnalyzeForeignTable
4918 * Test whether analyzing this foreign table is supported
4919 */
4920 static bool
4924 {
4928 StringInfoData sql;
4931 /* Return the row-analysis function pointer */
4934 /*
4935 * Now we have to get the number of pages. It's annoying that the ANALYZE
4936 * API requires us to return that now, because it forces some duplication
4937 * of effort between this routine and postgresAcquireSampleRowsFunc. But
4938 * it's probably not worth redefining that API at this point.
4939 */
4941 /*
4942 * Get the connection to use. We do the remote access as the table's
4943 * owner, even if the ANALYZE was started by some other user.
4944 */
4949 /*
4950 * Construct command to get page count for relation.
4951 */
4955 /* In what follows, do not risk leaking any PGresults. */
4957 {
4965 }
4967 {
4969 }
4975 }
4977 /*
4978 * postgresGetAnalyzeInfoForForeignTable
4979 * Count tuples in foreign table (just get pg_class.reltuples).
4980 *
4981 * can_tablesample determines if the remote relation supports acquiring the
4982 * sample using TABLESAMPLE.
4983 */
4984 static double
4986 {
4990 StringInfoData sql;
4995 /* assume the remote relation does not support TABLESAMPLE */
4998 /*
4999 * Get the connection to use. We do the remote access as the table's
5000 * owner, even if the ANALYZE was started by some other user.
5001 */
5006 /*
5007 * Construct command to get page count for relation.
5008 */
5012 /* In what follows, do not risk leaking any PGresults. */
5014 {
5023 }
5025 {
5028 }
5033 /* TABLESAMPLE is supported only for regular tables and matviews */
5039 }
5041 /*
5042 * Acquire a random sample of rows from foreign table managed by postgres_fdw.
5043 *
5044 * Selected rows are returned in the caller-allocated array rows[],
5045 * which must have at least targrows entries.
5046 * The actual number of rows selected is returned as the function result.
5047 * We also count the total number of rows in the table and return it into
5048 * *totalrows. Note that *totaldeadrows is always set to 0.
5049 *
5050 * Note that the returned list of rows is not always in order by physical
5051 * position in the table. Therefore, correlation estimates derived later
5052 * may be meaningless, but it's OK because we don't use the estimates
5053 * currently (the planner only pays attention to correlation for indexscans).
5054 */
5055 static int
5060 {
5061 PgFdwAnalyzeState astate;
5071 StringInfoData sql;
5075 /* Initialize workspace state */
5086 /* Remember ANALYZE context, and create a per-tuple temp context */
5090 ALLOCSET_SMALL_SIZES);
5092 /*
5093 * Get the connection to use. We do the remote access as the table's
5094 * owner, even if the ANALYZE was started by some other user.
5095 */
5101 /* We'll need server version, so fetch it now. */
5104 /*
5105 * What sampling method should we use?
5106 */
5108 {
5112 {
5127 }
5128 }
5131 {
5135 {
5150 }
5151 }
5153 /*
5154 * Error-out if explicitly required one of the TABLESAMPLE methods, but
5155 * the server does not support it.
5156 */
5164 /*
5165 * If we've decided to do remote sampling, calculate the sampling rate. We
5166 * need to get the number of tuples from the remote server, but skip that
5167 * network round-trip if not needed.
5168 */
5170 {
5176 /*
5177 * Make sure we're not choosing TABLESAMPLE when the remote relation
5178 * does not support that. But only do this for "auto" - if the user
5179 * explicitly requested BERNOULLI/SYSTEM, it's better to fail.
5180 */
5184 /*
5185 * Remote's reltuples could be 0 or -1 if the table has never been
5186 * vacuumed/analyzed. In that case, disable sampling after all.
5187 */
5190 else
5191 {
5192 /*
5193 * All supported sampling methods require sampling rate, not
5194 * target rows directly, so we calculate that using the remote
5195 * reltuples value. That's imperfect, because it might be off a
5196 * good deal, but that's not something we can (or should) address
5197 * here.
5198 *
5199 * If reltuples is too low (i.e. when table grew), we'll end up
5200 * sampling more rows - but then we'll apply the local sampling,
5201 * so we get the expected sample size. This is the same outcome as
5202 * without remote sampling.
5203 *
5204 * If reltuples is too high (e.g. after bulk DELETE), we will end
5205 * up sampling too few rows.
5206 *
5207 * We can't really do much better here - we could try sampling a
5208 * bit more rows, but we don't know how off the reltuples value is
5209 * so how much is "a bit more"?
5210 *
5211 * Furthermore, the targrows value for partitions is determined
5212 * based on table size (relpages), which can be off in different
5213 * ways too. Adjusting the sampling rate here might make the issue
5214 * worse.
5215 */
5218 /*
5219 * We should never get sampling rate outside the valid range
5220 * (between 0.0 and 1.0), because those cases should be covered by
5221 * the previous branch that sets ANALYZE_SAMPLE_OFF.
5222 */
5224 }
5225 }
5227 /*
5228 * For "auto" method, pick the one we believe is best. For servers with
5229 * TABLESAMPLE support we pick BERNOULLI, for old servers we fall-back to
5230 * random() to at least reduce network transfer.
5231 */
5233 {
5236 else
5238 }
5240 /*
5241 * Construct cursor that retrieves whole rows from remote.
5242 */
5249 /* In what follows, do not risk leaking any PGresults. */
5251 {
5261 /*
5262 * Determine the fetch size. The default is arbitrary, but shouldn't
5263 * be enormous.
5264 */
5267 {
5271 {
5274 }
5275 }
5277 {
5281 {
5284 }
5285 }
5287 /* Construct command to fetch rows from remote. */
5291 /* Retrieve and process rows a batch at a time. */
5293 {
5297 /* Allow users to cancel long query */
5300 /*
5301 * XXX possible future improvement: if rowstoskip is large, we
5302 * could issue a MOVE rather than physically fetching the rows,
5303 * then just adjust rowstoskip and samplerows appropriately.
5304 */
5306 /* Fetch some rows */
5308 /* On error, report the original query, not the FETCH. */
5312 /* Process whatever we got. */
5320 /* Must be EOF if we didn't get all the rows requested. */
5323 }
5325 /* Close the cursor, just to be tidy. */
5327 }
5329 {
5332 }
5337 /* We assume that we have no dead tuple. */
5340 /*
5341 * Without sampling, we've retrieved all living tuples from foreign
5342 * server, so report that as totalrows. Otherwise use the reltuples
5343 * estimate we got from the remote side.
5344 */
5347 else
5350 /*
5351 * Emit some interesting relation info
5352 */
5359 }
5361 /*
5362 * Collect sample rows from the result of query.
5363 * - Use all tuples in sample until target # of samples are collected.
5364 * - Subsequently, replace already-sampled tuples randomly.
5365 */
5366 static void
5368 {
5371 MemoryContext oldcontext;
5373 /* Always increment sample row counter. */
5376 /*
5377 * Determine the slot where this sample row should be stored. Set pos to
5378 * negative value to indicate the row should be skipped.
5379 */
5381 {
5382 /* First targrows rows are always included into the sample */
5384 }
5385 else
5386 {
5387 /*
5388 * Now we start replacing tuples in the sample until we reach the end
5389 * of the relation. Same algorithm as in acquire_sample_rows in
5390 * analyze.c; see Jeff Vitter's paper.
5391 */
5396 {
5397 /* Choose a random reservoir element to replace. */
5401 }
5402 else
5403 {
5404 /* Skip this tuple. */
5406 }
5409 }
5412 {
5413 /*
5414 * Create sample tuple from current result row, and store it in the
5415 * position determined above. The tuple has to be created in anl_cxt.
5416 */
5423 NULL,
5427 }
5428 }
5430 /*
5431 * Import a foreign schema
5432 */
5435 {
5444 StringInfoData buf;
5447 i;
5450 /* Parse statement options */
5452 {
5463 else
5467 }
5469 /*
5470 * Get connection to the foreign server. Connection manager will
5471 * establish new connection if necessary.
5472 */
5477 /* Don't attempt to import collation if remote server hasn't got it */
5481 /* Create workspace for strings */
5484 /* In what follows, do not risk leaking any PGresults. */
5486 {
5487 /* Check that the schema really exists */
5505 /*
5506 * Fetch all table data from this schema, possibly restricted by
5507 * EXCEPT or LIMIT TO. (We don't actually need to pay any attention
5508 * to EXCEPT/LIMIT TO here, because the core code will filter the
5509 * statements we return according to those lists anyway. But it
5510 * should save a few cycles to not process excluded tables in the
5511 * first place.)
5512 *
5513 * Import table data for partitions only when they are explicitly
5514 * specified in LIMIT TO clause. Otherwise ignore them and only
5515 * include the definitions of the root partitioned tables to allow
5516 * access to the complete remote data set locally in the schema
5517 * imported.
5518 *
5519 * Note: because we run the connection with search_path restricted to
5520 * pg_catalog, the format_type() and pg_get_expr() outputs will always
5521 * include a schema name for types/functions in other schemas, which
5522 * is what we want.
5523 */
5525 "SELECT relname, "
5526 " attname, "
5527 " format_type(atttypid, atttypmod), "
5528 " attnotnull, "
5531 /* Generated columns are supported since Postgres 12 */
5535 else
5541 " collname, "
5543 else
5548 "FROM pg_class c "
5549 " JOIN pg_namespace n ON "
5550 " relnamespace = n.oid "
5551 " LEFT JOIN pg_attribute a ON "
5552 " attrelid = c.oid AND attnum > 0 "
5553 " AND NOT attisdropped "
5554 " LEFT JOIN pg_attrdef ad ON "
5559 " LEFT JOIN pg_collation coll ON "
5560 " coll.oid = attcollation "
5561 " LEFT JOIN pg_namespace collnsp ON "
5565 "WHERE c.relkind IN ("
5574 /* Partitions are supported since Postgres 10 */
5579 /* Apply restrictions for LIMIT TO and EXCEPT */
5582 {
5590 /* Append list of table names within IN clause */
5592 {
5597 else
5600 }
5602 }
5604 /* Append ORDER BY at the end of query to ensure output ordering */
5607 /* Fetch the data */
5612 /* Process results */
5614 /* note: incrementation of i happens in inner loop's while() test */
5616 {
5624 /* Scan all rows for this table */
5625 do
5626 {
5635 /* If table has no columns, we'll see nulls here */
5653 else
5656 /* Print column name and type */
5659 typename);
5661 /*
5662 * Add column_name option so that renaming the foreign table's
5663 * column doesn't break the association to the underlying
5664 * column.
5665 */
5670 /* Add COLLATE if needed */
5676 /* Add DEFAULT if needed */
5681 /* Add GENERATED if needed */
5684 {
5688 attdefault);
5689 }
5691 /* Add NOT NULL if needed */
5694 }
5698 /*
5699 * Add server name and table-level options. We specify remote
5700 * schema and table name as options (the latter to ensure that
5701 * renaming the foreign table doesn't break the association).
5702 */
5714 }
5715 }
5717 {
5719 }
5725 }
5727 /*
5728 * Assess whether the join between inner and outer relations can be pushed down
5729 * to the foreign server. As a side effect, save information we obtain in this
5730 * function to PgFdwRelationInfo passed in.
5731 */
5732 static bool
5736 {
5743 /*
5744 * We support pushing down INNER, LEFT, RIGHT and FULL OUTER joins.
5745 * Constructing queries representing SEMI and ANTI joins is hard, hence
5746 * not considered right now.
5747 */
5752 /*
5753 * If either of the joining relations is marked as unsafe to pushdown, the
5754 * join can not be pushed down.
5755 */
5763 /*
5764 * If joining relations have local conditions, those conditions are
5765 * required to be applied before joining the relations. Hence the join can
5766 * not be pushed down.
5767 */
5771 /*
5772 * Merge FDW options. We might be tempted to do this after we have deemed
5773 * the foreign join to be OK. But we must do this beforehand so that we
5774 * know which quals can be evaluated on the foreign server, which might
5775 * depend on shippable_extensions.
5776 */
5780 /*
5781 * Separate restrict list into join quals and pushed-down (other) quals.
5782 *
5783 * Join quals belonging to an outer join must all be shippable, else we
5784 * cannot execute the join remotely. Add such quals to 'joinclauses'.
5785 *
5786 * Add other quals to fpinfo->remote_conds if they are shippable, else to
5787 * fpinfo->local_conds. In an inner join it's okay to execute conditions
5788 * either locally or remotely; the same is true for pushed-down conditions
5789 * at an outer join.
5790 *
5791 * Note we might return failure after having already scribbled on
5792 * fpinfo->remote_conds and fpinfo->local_conds. That's okay because we
5793 * won't consult those lists again if we deem the join unshippable.
5794 */
5797 {
5804 {
5808 }
5809 else
5810 {
5813 else
5815 }
5816 }
5818 /*
5819 * deparseExplicitTargetList() isn't smart enough to handle anything other
5820 * than a Var. In particular, if there's some PlaceHolderVar that would
5821 * need to be evaluated within this join tree (because there's an upper
5822 * reference to a quantity that may go to NULL as a result of an outer
5823 * join), then we can't try to push the join down because we'll fail when
5824 * we get to deparseExplicitTargetList(). However, a PlaceHolderVar that
5825 * needs to be evaluated *at the top* of this join tree is OK, because we
5826 * can do that locally after fetching the results from the remote side.
5827 */
5829 {
5831 Relids relids;
5833 /* PlaceHolderInfo refers to parent relids, not child relids. */
5840 }
5842 /* Save the join clauses, for later use. */
5849 /*
5850 * By default, both the input relations are not required to be deparsed as
5851 * subqueries, but there might be some relations covered by the input
5852 * relations that are required to be deparsed as subqueries, so save the
5853 * relids of those relations for later use by the deparser.
5854 */
5862 /*
5863 * Pull the other remote conditions from the joining relations into join
5864 * clauses or other remote clauses (remote_conds) of this relation
5865 * wherever possible. This avoids building subqueries at every join step.
5866 *
5867 * For an inner join, clauses from both the relations are added to the
5868 * other remote clauses. For LEFT and RIGHT OUTER join, the clauses from
5869 * the outer side are added to remote_conds since those can be evaluated
5870 * after the join is evaluated. The clauses from inner side are added to
5871 * the joinclauses, since they need to be evaluated while constructing the
5872 * join.
5873 *
5874 * For a FULL OUTER JOIN, the other clauses from either relation can not
5875 * be added to the joinclauses or remote_conds, since each relation acts
5876 * as an outer relation for the other.
5877 *
5878 * The joining sides can not have local conditions, thus no need to test
5879 * shippability of the clauses being pulled up.
5880 */
5882 {
5906 /*
5907 * In this case, if any of the input relations has conditions, we
5908 * need to deparse that relation as a subquery so that the
5909 * conditions can be evaluated before the join. Remember it in
5910 * the fpinfo of this relation so that the deparser can take
5911 * appropriate action. Also, save the relids of base relations
5912 * covered by that relation for later use by the deparser.
5913 */
5915 {
5920 }
5922 {
5927 }
5931 /* Should not happen, we have just checked this above */
5933 }
5935 /*
5936 * For an inner join, all restrictions can be treated alike. Treating the
5937 * pushed down conditions as join conditions allows a top level full outer
5938 * join to be deparsed without requiring subqueries.
5939 */
5941 {
5945 }
5947 /* Mark that this join can be pushed down safely */
5950 /* Get user mapping */
5952 {
5955 else
5957 }
5958 else
5961 /*
5962 * Set # of retrieved rows and cached relation costs to some negative
5963 * value, so that we can detect when they are set to some sensible values,
5964 * during one (usually the first) of the calls to estimate_path_cost_size.
5965 */
5970 /*
5971 * Set the string describing this join relation to be used in EXPLAIN
5972 * output of corresponding ForeignScan. Note that the decoration we add
5973 * to the base relation names mustn't include any digits, or it'll confuse
5974 * postgresExplainForeignScan.
5975 */
5981 /*
5982 * Set the relation index. This is defined as the position of this
5983 * joinrel in the join_rel_list list plus the length of the rtable list.
5984 * Note that since this joinrel is at the end of the join_rel_list list
5985 * when we are called, we can get the position by list_length.
5986 */
5992 }
5994 static void
5997 {
6003 /*
6004 * Before creating sorted paths, arrange for the passed-in EPQ path, if
6005 * any, to return columns needed by the parent ForeignScan node so that
6006 * they will propagate up through Sort nodes injected below, if necessary.
6007 */
6009 {
6013 /* Include columns required for evaluating PHVs in the tlist. */
6016 PVC_RECURSE_PLACEHOLDERS));
6018 /* Include columns required for evaluating the local conditions. */
6020 {
6025 PVC_RECURSE_PLACEHOLDERS));
6026 }
6028 /*
6029 * If we have added any new columns, adjust the tlist of the EPQ path.
6030 *
6031 * Note: the plan created using this path will only be used to execute
6032 * EPQ checks, where accuracy of the plan cost and width estimates
6033 * would not be important, so we do not do set_pathtarget_cost_width()
6034 * for the new pathtarget here. See also postgresGetForeignPlan().
6035 */
6037 {
6038 /* The EPQ path is a join path, so it is projection-capable. */
6041 /*
6042 * Use create_projection_path() here, so as to avoid modifying it
6043 * in place.
6044 */
6046 rel,
6047 epq_path,
6048 target);
6049 }
6050 }
6052 /* Create one path for each set of pathkeys we found above. */
6054 {
6057 Cost startup_cost;
6058 Cost total_cost;
6065 /*
6066 * The EPQ path must be at least as well sorted as the path itself, in
6067 * case it gets used as input to a mergejoin.
6068 */
6075 rel,
6076 sorted_epq_path,
6077 useful_pathkeys,
6083 NULL,
6084 rows,
6085 startup_cost,
6086 total_cost,
6087 useful_pathkeys,
6089 sorted_epq_path,
6091 * list */
6092 NIL));
6093 else
6096 NULL,
6097 rows,
6098 startup_cost,
6099 total_cost,
6100 useful_pathkeys,
6102 sorted_epq_path,
6103 restrictlist,
6104 NIL));
6105 }
6106 }
6108 /*
6109 * Parse options from foreign server and apply them to fpinfo.
6110 *
6111 * New options might also require tweaking merge_fdw_options().
6112 */
6113 static void
6115 {
6119 {
6126 NULL);
6129 NULL);
6137 }
6138 }
6140 /*
6141 * Parse options from foreign table and apply them to fpinfo.
6142 *
6143 * New options might also require tweaking merge_fdw_options().
6144 */
6145 static void
6147 {
6151 {
6160 }
6161 }
6163 /*
6164 * Merge FDW options from input relations into a new set of options for a join
6165 * or an upper rel.
6166 *
6167 * For a join relation, FDW-specific information about the inner and outer
6168 * relations is provided using fpinfo_i and fpinfo_o. For an upper relation,
6169 * fpinfo_o provides the information for the input relation; fpinfo_i is
6170 * expected to NULL.
6171 */
6172 static void
6176 {
6177 /* We must always have fpinfo_o. */
6180 /* fpinfo_i may be NULL, but if present the servers must both match. */
6184 /*
6185 * Copy the server specific FDW options. (For a join, both relations come
6186 * from the same server, so the server options should have the same value
6187 * for both relations.)
6188 */
6196 /* Merge the table level options from either side of the join. */
6198 {
6199 /*
6200 * We'll prefer to use remote estimates for this join if any table
6201 * from either side of the join is using remote estimates. This is
6202 * most likely going to be preferred since they're already willing to
6203 * pay the price of a round trip to get the remote EXPLAIN. In any
6204 * case it's not entirely clear how we might otherwise handle this
6205 * best.
6206 */
6210 /*
6211 * Set fetch size to maximum of the joining sides, since we are
6212 * expecting the rows returned by the join to be proportional to the
6213 * relation sizes.
6214 */
6217 /*
6218 * We'll prefer to consider this join async-capable if any table from
6219 * either side of the join is considered async-capable. This would be
6220 * reasonable because in that case the foreign server would have its
6221 * own resources to scan that table asynchronously, and the join could
6222 * also be computed asynchronously using the resources.
6223 */
6226 }
6227 }
6229 /*
6230 * postgresGetForeignJoinPaths
6231 * Add possible ForeignPath to joinrel, if join is safe to push down.
6232 */
6233 static void
6238 JoinType jointype,
6240 {
6245 Cost startup_cost;
6246 Cost total_cost;
6248 * EvalPlanQual gets triggered. */
6250 /*
6251 * Skip if this join combination has been considered already.
6252 */
6256 /*
6257 * This code does not work for joins with lateral references, since those
6258 * must have parameterized paths, which we don't generate yet.
6259 */
6263 /*
6264 * Create unfinished PgFdwRelationInfo entry which is used to indicate
6265 * that the join relation is already considered, so that we won't waste
6266 * time in judging safety of join pushdown and adding the same paths again
6267 * if found safe. Once we know that this join can be pushed down, we fill
6268 * the entry.
6269 */
6273 /* attrs_used is only for base relations. */
6276 /*
6277 * If there is a possibility that EvalPlanQual will be executed, we need
6278 * to be able to reconstruct the row using scans of the base relations.
6279 * GetExistingLocalJoinPath will find a suitable path for this purpose in
6280 * the path list of the joinrel, if one exists. We must be careful to
6281 * call it before adding any ForeignPath, since the ForeignPath might
6282 * dominate the only suitable local path available. We also do it before
6283 * calling foreign_join_ok(), since that function updates fpinfo and marks
6284 * it as pushable if the join is found to be pushable.
6285 */
6289 {
6292 {
6293 elog(DEBUG3, "could not push down foreign join because a local path suitable for EPQ checks was not found");
6295 }
6296 }
6297 else
6301 {
6302 /* Free path required for EPQ if we copied one; we don't need it now */
6306 }
6308 /*
6309 * Compute the selectivity and cost of the local_conds, so we don't have
6310 * to do it over again for each path. The best we can do for these
6311 * conditions is to estimate selectivity on the basis of local statistics.
6312 * The local conditions are applied after the join has been computed on
6313 * the remote side like quals in WHERE clause, so pass jointype as
6314 * JOIN_INNER.
6315 */
6319 JOIN_INNER,
6320 NULL);
6323 /*
6324 * If we are going to estimate costs locally, estimate the join clause
6325 * selectivity here while we have special join info.
6326 */
6332 /* Estimate costs for bare join relation */
6335 /* Now update this information in the joinrel */
6343 /*
6344 * Create a new join path and add it to the joinrel which represents a
6345 * join between foreign tables.
6346 */
6348 joinrel,
6350 rows,
6351 startup_cost,
6352 total_cost,
6355 epq_path,
6359 /* Add generated path into joinrel by add_path(). */
6362 /* Consider pathkeys for the join relation */
6366 /* XXX Consider parameterized paths for the join relation */
6367 }
6369 /*
6370 * Assess whether the aggregation, grouping and having operations can be pushed
6371 * down to the foreign server. As a side effect, save information we obtain in
6372 * this function to PgFdwRelationInfo of the input relation.
6373 */
6374 static bool
6377 {
6386 /* We currently don't support pushing Grouping Sets. */
6390 /* Get the fpinfo of the underlying scan relation. */
6393 /*
6394 * If underlying scan relation has any local conditions, those conditions
6395 * are required to be applied before performing aggregation. Hence the
6396 * aggregate cannot be pushed down.
6397 */
6401 /*
6402 * Examine grouping expressions, as well as other expressions we'd need to
6403 * compute, and check whether they are safe to push down to the foreign
6404 * server. All GROUP BY expressions will be part of the grouping target
6405 * and thus there is no need to search for them separately. Add grouping
6406 * expressions into target list which will be passed to foreign server.
6407 *
6408 * A tricky fine point is that we must not put any expression into the
6409 * target list that is just a foreign param (that is, something that
6410 * deparse.c would conclude has to be sent to the foreign server). If we
6411 * do, the expression will also appear in the fdw_exprs list of the plan
6412 * node, and setrefs.c will get confused and decide that the fdw_exprs
6413 * entry is actually a reference to the fdw_scan_tlist entry, resulting in
6414 * a broken plan. Somewhat oddly, it's OK if the expression contains such
6415 * a node, as long as it's not at top level; then no match is possible.
6416 */
6419 {
6424 /*
6425 * Check whether this expression is part of GROUP BY clause. Note we
6426 * check the whole GROUP BY clause not just processed_groupClause,
6427 * because we will ship all of it, cf. appendGroupByClause.
6428 */
6430 {
6433 /*
6434 * If any GROUP BY expression is not shippable, then we cannot
6435 * push down aggregation to the foreign server.
6436 */
6440 /*
6441 * If it would be a foreign param, we can't put it into the tlist,
6442 * so we have to fail.
6443 */
6447 /*
6448 * Pushable, so add to tlist. We need to create a TLE for this
6449 * expression and apply the sortgroupref to it. We cannot use
6450 * add_to_flat_tlist() here because that avoids making duplicate
6451 * entries in the tlist. If there are duplicate entries with
6452 * distinct sortgrouprefs, we have to duplicate that situation in
6453 * the output tlist.
6454 */
6458 }
6459 else
6460 {
6461 /*
6462 * Non-grouping expression we need to compute. Can we ship it
6463 * as-is to the foreign server?
6464 */
6467 {
6468 /* Yes, so add to tlist as-is; OK to suppress duplicates */
6470 }
6471 else
6472 {
6473 /* Not pushable as a whole; extract its Vars and aggregates */
6477 PVC_INCLUDE_AGGREGATES);
6479 /*
6480 * If any aggregate expression is not shippable, then we
6481 * cannot push down aggregation to the foreign server. (We
6482 * don't have to check is_foreign_param, since that certainly
6483 * won't return true for any such expression.)
6484 */
6488 /*
6489 * Add aggregates, if any, into the targetlist. Plain Vars
6490 * outside an aggregate can be ignored, because they should be
6491 * either same as some GROUP BY column or part of some GROUP
6492 * BY expression. In either case, they are already part of
6493 * the targetlist and thus no need to add them again. In fact
6494 * including plain Vars in the tlist when they do not match a
6495 * GROUP BY column would cause the foreign server to complain
6496 * that the shipped query is invalid.
6497 */
6499 {
6504 }
6505 }
6506 }
6508 i++;
6509 }
6511 /*
6512 * Classify the pushable and non-pushable HAVING clauses and save them in
6513 * remote_conds and local_conds of the grouped rel's fpinfo.
6514 */
6516 {
6518 {
6522 /*
6523 * Currently, the core code doesn't wrap havingQuals in
6524 * RestrictInfos, so we must make our own.
6525 */
6528 expr,
6535 NULL,
6536 NULL);
6539 else
6541 }
6542 }
6544 /*
6545 * If there are any local conditions, pull Vars and aggregates from it and
6546 * check whether they are safe to pushdown or not.
6547 */
6549 {
6553 {
6558 PVC_INCLUDE_AGGREGATES));
6559 }
6562 {
6565 /*
6566 * If aggregates within local conditions are not safe to push
6567 * down, then we cannot push down the query. Vars are already
6568 * part of GROUP BY clause which are checked above, so no need to
6569 * access them again here. Again, we need not check
6570 * is_foreign_param for a foreign aggregate.
6571 */
6573 {
6578 }
6579 }
6580 }
6582 /* Store generated targetlist */
6585 /* Safe to pushdown */
6588 /*
6589 * Set # of retrieved rows and cached relation costs to some negative
6590 * value, so that we can detect when they are set to some sensible values,
6591 * during one (usually the first) of the calls to estimate_path_cost_size.
6592 */
6597 /*
6598 * Set the string describing this grouped relation to be used in EXPLAIN
6599 * output of corresponding ForeignScan. Note that the decoration we add
6600 * to the base relation name mustn't include any digits, or it'll confuse
6601 * postgresExplainForeignScan.
6602 */
6607 }
6609 /*
6610 * postgresGetForeignUpperPaths
6611 * Add paths for post-join operations like aggregation, grouping etc. if
6612 * corresponding operations are safe to push down.
6613 */
6614 static void
6618 {
6621 /*
6622 * If input rel is not safe to pushdown, then simply return as we cannot
6623 * perform any post-join operations on the foreign server.
6624 */
6629 /* Ignore stages we don't support; and skip any duplicate calls. */
6642 {
6657 }
6658 }
6660 /*
6661 * add_foreign_grouping_paths
6662 * Add foreign path for grouping and/or aggregation.
6663 *
6664 * Given input_rel represents the underlying scan. The paths are added to the
6665 * given grouped_rel.
6666 */
6667 static void
6671 {
6678 Cost startup_cost;
6679 Cost total_cost;
6681 /* Nothing to be done, if there is no grouping or aggregation required. */
6689 /* save the input_rel as outerrel in fpinfo */
6692 /*
6693 * Copy foreign table, foreign server, user mapping, FDW options etc.
6694 * details from the input relation's fpinfo.
6695 */
6701 /*
6702 * Assess if it is safe to push down aggregation and grouping.
6703 *
6704 * Use HAVING qual from extra. In case of child partition, it will have
6705 * translated Vars.
6706 */
6710 /*
6711 * Compute the selectivity and cost of the local_conds, so we don't have
6712 * to do it over again for each path. (Currently we create just a single
6713 * path here, but in future it would be possible that we build more paths
6714 * such as pre-sorted paths as in postgresGetForeignPaths and
6715 * postgresGetForeignJoinPaths.) The best we can do for these conditions
6716 * is to estimate selectivity on the basis of local statistics.
6717 */
6721 JOIN_INNER,
6722 NULL);
6726 /* Estimate the cost of push down */
6730 /* Now update this information in the fpinfo */
6736 /* Create and add foreign path to the grouping relation. */
6738 grouped_rel,
6740 rows,
6741 startup_cost,
6742 total_cost,
6744 NULL,
6748 /* Add generated path into grouped_rel by add_path(). */
6750 }
6752 /*
6753 * add_foreign_ordered_paths
6754 * Add foreign paths for performing the final sort remotely.
6755 *
6756 * Given input_rel contains the source-data Paths. The paths are added to the
6757 * given ordered_rel.
6758 */
6759 static void
6762 {
6769 Cost startup_cost;
6770 Cost total_cost;
6775 /* Shouldn't get here unless the query has ORDER BY */
6778 /* We don't support cases where there are any SRFs in the targetlist */
6782 /* Save the input_rel as outerrel in fpinfo */
6785 /*
6786 * Copy foreign table, foreign server, user mapping, FDW options etc.
6787 * details from the input relation's fpinfo.
6788 */
6794 /*
6795 * If the input_rel is a base or join relation, we would already have
6796 * considered pushing down the final sort to the remote server when
6797 * creating pre-sorted foreign paths for that relation, because the
6798 * query_pathkeys is set to the root->sort_pathkeys in that case (see
6799 * standard_qp_callback()).
6800 */
6803 {
6806 /* Safe to push down if the query_pathkeys is safe to push down */
6810 }
6812 /* The input_rel should be a grouping relation */
6816 /*
6817 * We try to create a path below by extending a simple foreign path for
6818 * the underlying grouping relation to perform the final sort remotely,
6819 * which is stored into the fdw_private list of the resulting path.
6820 */
6822 /* Assess if it is safe to push down the final sort */
6824 {
6828 /*
6829 * is_foreign_expr would detect volatile expressions as well, but
6830 * checking ec_has_volatile here saves some cycles.
6831 */
6835 /*
6836 * Can't push down the sort if pathkey's opfamily is not shippable.
6837 */
6839 fpinfo))
6842 /*
6843 * The EC must contain a shippable EM that is computed in input_rel's
6844 * reltarget, else we can't push down the sort.
6845 */
6847 pathkey_ec,
6850 }
6852 /* Safe to push down */
6855 /* Construct PgFdwPathExtraData */
6860 /* Estimate the costs of performing the final sort remotely */
6864 /*
6865 * Build the fdw_private list that will be used by postgresGetForeignPlan.
6866 * Items in the list must match order in enum FdwPathPrivateIndex.
6867 */
6870 /* Create foreign ordering path */
6872 input_rel,
6874 rows,
6875 startup_cost,
6876 total_cost,
6880 * list */
6881 fdw_private);
6883 /* and add it to the ordered_rel */
6885 }
6887 /*
6888 * add_foreign_final_paths
6889 * Add foreign paths for performing the final processing remotely.
6890 *
6891 * Given input_rel contains the source-data Paths. The paths are added to the
6892 * given final_rel.
6893 */
6894 static void
6898 {
6908 Cost startup_cost;
6909 Cost total_cost;
6913 /*
6914 * Currently, we only support this for SELECT commands
6915 */
6919 /*
6920 * No work if there is no FOR UPDATE/SHARE clause and if there is no need
6921 * to add a LIMIT node
6922 */
6926 /* We don't support cases where there are any SRFs in the targetlist */
6930 /* Save the input_rel as outerrel in fpinfo */
6933 /*
6934 * Copy foreign table, foreign server, user mapping, FDW options etc.
6935 * details from the input relation's fpinfo.
6936 */
6942 /*
6943 * If there is no need to add a LIMIT node, there might be a ForeignPath
6944 * in the input_rel's pathlist that implements all behavior of the query.
6945 * Note: we would already have accounted for the query's FOR UPDATE/SHARE
6946 * (if any) before we get here.
6947 */
6949 {
6954 /*
6955 * Grouping and aggregation are not supported with FOR UPDATE/SHARE,
6956 * so the input_rel should be a base, join, or ordered relation; and
6957 * if it's an ordered relation, its input relation should be a base or
6958 * join relation.
6959 */
6968 {
6971 /*
6972 * apply_scanjoin_target_to_paths() uses create_projection_path()
6973 * to adjust each of its input paths if needed, whereas
6974 * create_ordered_paths() uses apply_projection_to_path() to do
6975 * that. So the former might have put a ProjectionPath on top of
6976 * the ForeignPath; look through ProjectionPath and see if the
6977 * path underneath it is ForeignPath.
6978 */
6982 {
6983 /*
6984 * Create foreign final path; this gets rid of a
6985 * no-longer-needed outer plan (if any), which makes the
6986 * EXPLAIN output look cleaner
6987 */
6997 * list */
7000 /* and add it to the final_rel */
7003 /* Safe to push down */
7007 }
7008 }
7010 /*
7011 * If we get here it means no ForeignPaths; since we would already
7012 * have considered pushing down all operations for the query to the
7013 * remote server, give up on it.
7014 */
7016 }
7020 /*
7021 * If the input_rel is an ordered relation, replace the input_rel with its
7022 * input relation
7023 */
7026 {
7031 }
7033 /* The input_rel should be a base, join, or grouping relation */
7039 /*
7040 * We try to create a path below by extending a simple foreign path for
7041 * the underlying base, join, or grouping relation to perform the final
7042 * sort (if has_final_sort) and the LIMIT restriction remotely, which is
7043 * stored into the fdw_private list of the resulting path. (We
7044 * re-estimate the costs of sorting the underlying relation, if
7045 * has_final_sort.)
7046 */
7048 /*
7049 * Assess if it is safe to push down the LIMIT and OFFSET to the remote
7050 * server
7051 */
7053 /*
7054 * If the underlying relation has any local conditions, the LIMIT/OFFSET
7055 * cannot be pushed down.
7056 */
7060 /*
7061 * Also, the LIMIT/OFFSET cannot be pushed down, if their expressions are
7062 * not safe to remote.
7063 */
7068 /* Safe to push down */
7071 /* Construct PgFdwPathExtraData */
7080 /*
7081 * Estimate the costs of performing the final sort and the LIMIT
7082 * restriction remotely. If has_final_sort is false, we wouldn't need to
7083 * execute EXPLAIN anymore if use_remote_estimate, since the costs can be
7084 * roughly estimated using the costs we already have for the underlying
7085 * relation, in the same way as when use_remote_estimate is false. Since
7086 * it's pretty expensive to execute EXPLAIN, force use_remote_estimate to
7087 * false in that case.
7088 */
7090 {
7093 }
7099 /*
7100 * Build the fdw_private list that will be used by postgresGetForeignPlan.
7101 * Items in the list must match order in enum FdwPathPrivateIndex.
7102 */
7106 /*
7107 * Create foreign final path; this gets rid of a no-longer-needed outer
7108 * plan (if any), which makes the EXPLAIN output look cleaner
7109 */
7111 input_rel,
7113 rows,
7114 startup_cost,
7115 total_cost,
7116 pathkeys,
7119 fdw_private);
7121 /* and add it to the final_rel */
7123 }
7125 /*
7126 * postgresIsForeignPathAsyncCapable
7127 * Check whether a given ForeignPath node is async-capable.
7128 */
7129 static bool
7131 {
7136 }
7138 /*
7139 * postgresForeignAsyncRequest
7140 * Asynchronously request next tuple from a foreign PostgreSQL table.
7141 */
7142 static void
7144 {
7146 }
7148 /*
7149 * postgresForeignAsyncConfigureWait
7150 * Configure a file descriptor event for which we wish to wait.
7151 */
7152 static void
7154 {
7161 /* This should not be called unless callback_pending */
7164 /*
7165 * If process_pending_request() has been invoked on the given request
7166 * before we get here, we might have some tuples already; in which case
7167 * complete the request
7168 */
7170 {
7175 }
7177 /* We must have run out of tuples */
7180 /* The core code would have registered postmaster death event */
7183 /* Begin an asynchronous data fetch if not already done */
7187 {
7188 /*
7189 * This is the case when the in-process request was made by another
7190 * Append. Note that it might be useless to process the request,
7191 * because the query might not need tuples from that Append anymore.
7192 * If there are any child subplans of the same parent that are ready
7193 * for new requests, skip the given request. Likewise, if there are
7194 * any configured events other than the postmaster death event, skip
7195 * it. Otherwise, process the in-process request, then begin a fetch
7196 * to configure the event below, because we might otherwise end up
7197 * with no configured events other than the postmaster death event.
7198 */
7205 }
7207 {
7208 /*
7209 * This is the case when the in-process request was made by the same
7210 * parent but for a different child. Since we configure only the
7211 * event for the request made for that child, skip the given request.
7212 */
7214 }
7215 else
7220 }
7222 /*
7223 * postgresForeignAsyncNotify
7224 * Fetch some more tuples from a file descriptor that becomes ready,
7225 * requesting next tuple.
7226 */
7227 static void
7229 {
7233 /* The core code would have initialized the callback_pending flag */
7236 /*
7237 * If process_pending_request() has been invoked on the given request
7238 * before we get here, we might have some tuples already; in which case
7239 * produce the next tuple
7240 */
7242 {
7245 }
7247 /* We must have run out of tuples */
7250 /* The request should be currently in-process */
7253 /* On error, report the original query, not the FETCH. */
7260 }
7262 /*
7263 * Asynchronously produce next tuple from a foreign PostgreSQL table.
7264 */
7265 static void
7267 {
7273 /* This should not be called if the request is currently in-process */
7276 /* Fetch some more tuples, if we've run out */
7278 {
7279 /* No point in another fetch if we already detected EOF, though */
7281 {
7282 /* Mark the request as pending for a callback */
7284 /* Begin another fetch if requested and if no pending request */
7287 }
7288 else
7289 {
7290 /* There's nothing more to do; just return a NULL pointer */
7292 /* Mark the request as complete */
7294 }
7296 }
7298 /* Get a tuple from the ForeignScan node */
7301 {
7302 /* Mark the request as complete */
7305 }
7307 /* We must have run out of tuples */
7310 /* Fetch some more tuples, if we've not detected EOF yet */
7312 {
7313 /* Mark the request as pending for a callback */
7315 /* Begin another fetch if requested and if no pending request */
7318 }
7319 else
7320 {
7321 /* There's nothing more to do; just return a NULL pointer */
7323 /* Mark the request as complete */
7325 }
7326 }
7328 /*
7329 * Begin an asynchronous data fetch.
7330 *
7331 * Note: this function assumes there is no currently-in-progress asynchronous
7332 * data fetch.
7333 *
7334 * Note: fetch_more_data must be called to fetch the result.
7335 */
7336 static void
7338 {
7345 /* Create the cursor synchronously. */
7349 /* We will send this query, but not wait for the response. */
7356 /* Remember that the request is in process */
7358 }
7360 /*
7361 * Process a pending asynchronous request.
7362 */
7363 void
7365 {
7369 /* The request would have been pending for a callback */
7372 /* The request should be currently in-process */
7377 /*
7378 * If we didn't get any tuples, must be end of data; complete the request
7379 * now. Otherwise, we postpone completing the request until we are called
7380 * from postgresForeignAsyncConfigureWait()/postgresForeignAsyncNotify().
7381 */
7383 {
7384 /* Unlike AsyncNotify, we unset callback_pending ourselves */
7386 /* Mark the request as complete */
7388 /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
7390 }
7391 }
7393 /*
7394 * Complete a pending asynchronous request.
7395 */
7396 static void
7398 {
7399 /* The request would have been pending for a callback */
7402 /* Unlike AsyncNotify, we unset callback_pending ourselves */
7405 /* We begin a fetch afterwards if necessary; don't fetch */
7408 /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
7411 /* Also, we do instrumentation ourselves, if required */
7415 }
7417 /*
7418 * Create a tuple from the specified row of the PGresult.
7419 *
7420 * rel is the local representation of the foreign table, attinmeta is
7421 * conversion data for the rel's tupdesc, and retrieved_attrs is an
7422 * integer list of the table column numbers present in the PGresult.
7423 * fsstate is the ForeignScan plan node's execution state.
7424 * temp_context is a working context that can be reset after each tuple.
7425 *
7426 * Note: either rel or fsstate, but not both, can be NULL. rel is NULL
7427 * if we're processing a remote join, while fsstate is NULL in a non-query
7428 * context such as ANALYZE, or if we're processing a non-scan query node.
7429 */
7430 static HeapTuple
7433 Relation rel,
7437 MemoryContext temp_context)
7438 {
7439 HeapTuple tuple;
7440 TupleDesc tupdesc;
7444 ConversionLocation errpos;
7445 ErrorContextCallback errcallback;
7446 MemoryContext oldcontext;
7452 /*
7453 * Do the following work in a temp context that we reset after each tuple.
7454 * This cleans up not only the data we have direct access to, but any
7455 * cruft the I/O functions might leak.
7456 */
7459 /*
7460 * Get the tuple descriptor for the row. Use the rel's tupdesc if rel is
7461 * provided, otherwise look to the scan node's ScanTupleSlot.
7462 */
7465 else
7466 {
7469 }
7473 /* Initialize to nulls for any columns not present in result */
7476 /*
7477 * Set up and install callback to report where conversion error occurs.
7478 */
7487 /*
7488 * i indexes columns in the relation, j indexes columns in the PGresult.
7489 */
7492 {
7496 /* fetch next column's textual value */
7499 else
7502 /*
7503 * convert value to internal representation
7504 *
7505 * Note: we ignore system columns other than ctid and oid in result
7506 */
7509 {
7510 /* ordinary column */
7513 /* Apply the input function even to nulls, to support domains */
7515 valstr,
7518 }
7520 {
7521 /* ctid */
7523 {
7524 Datum datum;
7528 }
7529 }
7532 j++;
7533 }
7535 /* Uninstall error context callback. */
7538 /*
7539 * Check we got the expected number of columns. Note: j == 0 and
7540 * PQnfields == 1 is expected, since deparse emits a NULL if no columns.
7541 */
7545 /*
7546 * Build the result tuple in caller's memory context.
7547 */
7552 /*
7553 * If we have a CTID to return, install it in both t_self and t_ctid.
7554 * t_self is the normal place, but if the tuple is converted to a
7555 * composite Datum, t_self will be lost; setting t_ctid allows CTID to be
7556 * preserved during EvalPlanQual re-evaluations (see ROW_MARK_COPY code).
7557 */
7561 /*
7562 * Stomp on the xmin, xmax, and cmin fields from the tuple created by
7563 * heap_form_tuple. heap_form_tuple actually creates the tuple with
7564 * DatumTupleFields, not HeapTupleFields, but the executor expects
7565 * HeapTupleFields and will happily extract system columns on that
7566 * assumption. If we don't do this then, for example, the tuple length
7567 * ends up in the xmin field, which isn't what we want.
7568 */
7573 /* Clean up */
7577 }
7579 /*
7580 * Callback function which is called when error occurs during column value
7581 * conversion. Print names of column and relation.
7582 *
7583 * Note that this function mustn't do any catalog lookups, since we are in
7584 * an already-failed transaction. Fortunately, we can get the needed info
7585 * from the relation or the query's rangetable instead.
7586 */
7587 static void
7589 {
7597 /*
7598 * If we're in a scan node, always use aliases from the rangetable, for
7599 * consistency between the simple-relation and remote-join cases. Look at
7600 * the relation's tupdesc only if we're not in a scan node.
7601 */
7603 {
7604 /* ForeignScan case */
7610 {
7611 /* error occurred in a scan against a foreign table */
7614 }
7615 else
7616 {
7617 /* error occurred in a scan against a foreign join */
7623 /*
7624 * Target list can have Vars and expressions. For Vars, we can
7625 * get some information, however for expressions we can't. Thus
7626 * for expressions, just show generic context message.
7627 */
7629 {
7634 }
7635 }
7638 {
7650 }
7651 }
7653 {
7654 /* Non-ForeignScan case (we should always have a rel here) */
7659 {
7664 }
7667 }
7673 else
7676 }
7678 /*
7679 * Given an EquivalenceClass and a foreign relation, find an EC member
7680 * that can be used to sort the relation remotely according to a pathkey
7681 * using this EC.
7682 *
7683 * If there is more than one suitable candidate, return an arbitrary
7684 * one of them. If there is none, return NULL.
7685 *
7686 * This checks that the EC member expression uses only Vars from the given
7687 * rel and is shippable. Caller must separately verify that the pathkey's
7688 * ordering operator is shippable.
7689 */
7690 EquivalenceMember *
7692 {
7696 {
7699 /*
7700 * Note we require !bms_is_empty, else we'd accept constant
7701 * expressions which are not suitable for the purpose.
7702 */
7707 }
7710 }
7712 /*
7713 * Find an EquivalenceClass member that is to be computed as a sort column
7714 * in the given rel's reltarget, and is shippable.
7715 *
7716 * If there is more than one suitable candidate, return an arbitrary
7717 * one of them. If there is none, return NULL.
7718 *
7719 * This checks that the EC member expression uses only Vars from the given
7720 * rel and is shippable. Caller must separately verify that the pathkey's
7721 * ordering operator is shippable.
7722 */
7723 EquivalenceMember *
7726 {
7733 {
7738 /* Ignore non-sort expressions */
7742 {
7743 i++;
7745 }
7747 /* We ignore binary-compatible relabeling on both ends */
7751 /* Locate an EquivalenceClass member matching this expr, if any */
7753 {
7757 /* Don't match constants */
7761 /* Ignore child members */
7765 /* Match if same expression (after stripping relabel) */
7773 /* Check that expression (including relabels!) is shippable */
7776 }
7778 i++;
7779 }
7782 }
7784 /*
7785 * Determine batch size for a given foreign table. The option specified for
7786 * a table has precedence.
7787 */
7788 static int
7790 {
7797 /* we use 1 by default, which means "no batching" */
7800 /*
7801 * Load options for table and server. We append server options after table
7802 * options, because table options take precedence.
7803 */
7811 /* See if either table or server specifies batch_size. */
7813 {
7817 {
7820 }
7821 }
7824 }