| blob | c5cada55fb732942ba586aeecefc395b646ba55c |
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 */
1040 /* Add paths with pathkeys */
1043 /*
1044 * If we're not using remote estimates, stop here. We have no way to
1045 * estimate whether any join clauses would be worth sending across, so
1046 * don't bother building parameterized paths.
1047 */
1051 /*
1052 * Thumb through all join clauses for the rel to identify which outer
1053 * relations could supply one or more safe-to-send-to-remote join clauses.
1054 * We'll build a parameterized path for each such outer relation.
1055 *
1056 * It's convenient to manage this by representing each candidate outer
1057 * relation by the ParamPathInfo node for it. We can then use the
1058 * ppi_clauses list in the ParamPathInfo node directly as a list of the
1059 * interesting join clauses for that rel. This takes care of the
1060 * possibility that there are multiple safe join clauses for such a rel,
1061 * and also ensures that we account for unsafe join clauses that we'll
1062 * still have to enforce locally (since the parameterized-path machinery
1063 * insists that we handle all movable clauses).
1064 */
1067 {
1069 Relids required_outer;
1072 /* Check if clause can be moved to this rel */
1076 /* See if it is safe to send to remote */
1080 /* Calculate required outer rels for the resulting path */
1083 /* We do not want the foreign rel itself listed in required_outer */
1086 /*
1087 * required_outer probably can't be empty here, but if it were, we
1088 * couldn't make a parameterized path.
1089 */
1093 /* Get the ParamPathInfo */
1095 required_outer);
1098 /*
1099 * Add it to list unless we already have it. Testing pointer equality
1100 * is OK since get_baserel_parampathinfo won't make duplicates.
1101 */
1103 }
1105 /*
1106 * The above scan examined only "generic" join clauses, not those that
1107 * were absorbed into EquivalenceClauses. See if we can make anything out
1108 * of EquivalenceClauses.
1109 */
1111 {
1112 /*
1113 * We repeatedly scan the eclass list looking for column references
1114 * (or expressions) belonging to the foreign rel. Each time we find
1115 * one, we generate a list of equivalence joinclauses for it, and then
1116 * see if any are safe to send to the remote. Repeat till there are
1117 * no more candidate EC members.
1118 */
1119 ec_member_foreign_arg arg;
1123 {
1126 /* Make clauses, skipping any that join to lateral_referencers */
1129 baserel,
1130 ec_member_matches_foreign,
1134 /* Done if there are no more expressions in the foreign rel */
1136 {
1139 }
1141 /* Scan the extracted join clauses */
1143 {
1145 Relids required_outer;
1148 /* Check if clause can be moved to this rel */
1152 /* See if it is safe to send to remote */
1156 /* Calculate required outer rels for the resulting path */
1163 /* Get the ParamPathInfo */
1165 required_outer);
1168 /* Add it to list unless we already have it */
1170 }
1172 /* Try again, now ignoring the expression we found this time */
1174 }
1175 }
1177 /*
1178 * Now build a path for each useful outer relation.
1179 */
1181 {
1185 Cost startup_cost;
1186 Cost total_cost;
1188 /* Get a cost estimate from the remote */
1194 /*
1195 * ppi_rows currently won't get looked at by anything, but still we
1196 * may as well ensure that it matches our idea of the rowcount.
1197 */
1200 /* Make the path */
1203 rows,
1204 startup_cost,
1205 total_cost,
1208 NULL,
1211 }
1212 }
1214 /*
1215 * postgresGetForeignPlan
1216 * Create ForeignScan plan node which implements selected best path
1217 */
1221 Oid foreigntableid,
1226 {
1228 Index scan_relid;
1236 StringInfoData sql;
1241 /*
1242 * Get FDW private data created by postgresGetForeignUpperPaths(), if any.
1243 */
1245 {
1247 FdwPathPrivateHasFinalSort));
1249 FdwPathPrivateHasLimit));
1250 }
1253 {
1254 /*
1255 * For base relations, set scan_relid as the relid of the relation.
1256 */
1259 /*
1260 * In a base-relation scan, we must apply the given scan_clauses.
1261 *
1262 * Separate the scan_clauses into those that can be executed remotely
1263 * and those that can't. baserestrictinfo clauses that were
1264 * previously determined to be safe or unsafe by classifyConditions
1265 * are found in fpinfo->remote_conds and fpinfo->local_conds. Anything
1266 * else in the scan_clauses list will be a join clause, which we have
1267 * to check for remote-safety.
1268 *
1269 * Note: the join clauses we see here should be the exact same ones
1270 * previously examined by postgresGetForeignPaths. Possibly it'd be
1271 * worth passing forward the classification work done then, rather
1272 * than repeating it here.
1273 *
1274 * This code must match "extract_actual_clauses(scan_clauses, false)"
1275 * except for the additional decision about remote versus local
1276 * execution.
1277 */
1279 {
1282 /* Ignore any pseudoconstants, they're dealt with elsewhere */
1292 else
1294 }
1296 /*
1297 * For a base-relation scan, we have to support EPQ recheck, which
1298 * should recheck all the remote quals.
1299 */
1301 }
1302 else
1303 {
1304 /*
1305 * Join relation or upper relation - set scan_relid to 0.
1306 */
1309 /*
1310 * For a join rel, baserestrictinfo is NIL and we are not considering
1311 * parameterization right now, so there should be no scan_clauses for
1312 * a joinrel or an upper rel either.
1313 */
1316 /*
1317 * Instead we get the conditions to apply from the fdw_private
1318 * structure.
1319 */
1323 /*
1324 * We leave fdw_recheck_quals empty in this case, since we never need
1325 * to apply EPQ recheck clauses. In the case of a joinrel, EPQ
1326 * recheck is handled elsewhere --- see postgresGetForeignJoinPaths().
1327 * If we're planning an upperrel (ie, remote grouping or aggregation)
1328 * then there's no EPQ to do because SELECT FOR UPDATE wouldn't be
1329 * allowed, and indeed we *can't* put the remote clauses into
1330 * fdw_recheck_quals because the unaggregated Vars won't be available
1331 * locally.
1332 */
1334 /* Build the list of columns to be fetched from the foreign server. */
1337 /*
1338 * Ensure that the outer plan produces a tuple whose descriptor
1339 * matches our scan tuple slot. Also, remove the local conditions
1340 * from outer plan's quals, lest they be evaluated twice, once by the
1341 * local plan and once by the scan.
1342 */
1344 {
1345 /*
1346 * Right now, we only consider grouping and aggregation beyond
1347 * joins. Queries involving aggregates or grouping do not require
1348 * EPQ mechanism, hence should not have an outer plan here.
1349 */
1352 /*
1353 * First, update the plan's qual list if possible. In some cases
1354 * the quals might be enforced below the topmost plan level, in
1355 * which case we'll fail to remove them; it's not worth working
1356 * harder than this.
1357 */
1359 {
1364 /*
1365 * For an inner join the local conditions of foreign scan plan
1366 * can be part of the joinquals as well. (They might also be
1367 * in the mergequals or hashquals, but we can't touch those
1368 * without breaking the plan.)
1369 */
1373 {
1378 qual);
1379 }
1380 }
1382 /*
1383 * Now fix the subplan's tlist --- this might result in inserting
1384 * a Result node atop the plan tree.
1385 */
1388 }
1389 }
1391 /*
1392 * Build the query string to be sent for execution, and identify
1393 * expressions to be sent as parameters.
1394 */
1401 /* Remember remote_exprs for possible use by postgresPlanDirectModify */
1404 /*
1405 * Build the fdw_private list that will be available to the executor.
1406 * Items in the list must match order in enum FdwScanPrivateIndex.
1407 */
1409 retrieved_attrs,
1415 /*
1416 * Create the ForeignScan node for the given relation.
1417 *
1418 * Note that the remote parameter expressions are stored in the fdw_exprs
1419 * field of the finished plan node; we can't keep them in private state
1420 * because then they wouldn't be subject to later planner processing.
1421 */
1423 local_exprs,
1424 scan_relid,
1425 params_list,
1426 fdw_private,
1427 fdw_scan_tlist,
1428 fdw_recheck_quals,
1429 outer_plan);
1430 }
1432 /*
1433 * Construct a tuple descriptor for the scan tuples handled by a foreign join.
1434 */
1435 static TupleDesc
1437 {
1440 TupleDesc tupdesc;
1442 /*
1443 * The core code has already set up a scan tuple slot based on
1444 * fsplan->fdw_scan_tlist, and this slot's tupdesc is mostly good enough,
1445 * but there's one case where it isn't. If we have any whole-row row
1446 * identifier Vars, they may have vartype RECORD, and we need to replace
1447 * that with the associated table's actual composite type. This ensures
1448 * that when we read those ROW() expression values from the remote server,
1449 * we can convert them to a composite type the local server knows.
1450 */
1453 {
1457 Oid reltype;
1459 /* Nothing to do if it's not a generic RECORD attribute */
1463 /*
1464 * If we can't identify the referenced table, do nothing. This'll
1465 * likely lead to failure later, but perhaps we can muddle through.
1466 */
1478 /* shouldn't need to change anything else */
1479 }
1481 }
1483 /*
1484 * postgresBeginForeignScan
1485 * Initiate an executor scan of a foreign PostgreSQL table.
1486 */
1487 static void
1489 {
1494 Oid userid;
1500 /*
1501 * Do nothing in EXPLAIN (no ANALYZE) case. node->fdw_state stays NULL.
1502 */
1506 /*
1507 * We'll save private state in node->fdw_state.
1508 */
1512 /*
1513 * Identify which user to do the remote access as. This should match what
1514 * ExecCheckPermissions() does.
1515 */
1519 else
1523 /* Get info about foreign table. */
1527 /*
1528 * Get connection to the foreign server. Connection manager will
1529 * establish new connection if necessary.
1530 */
1533 /* Assign a unique ID for my cursor */
1537 /* Get private info created by planner functions. */
1539 FdwScanPrivateSelectSql));
1541 FdwScanPrivateRetrievedAttrs);
1543 FdwScanPrivateFetchSize));
1545 /* Create contexts for batches of tuples and per-tuple temp workspace. */
1548 ALLOCSET_DEFAULT_SIZES);
1551 ALLOCSET_SMALL_SIZES);
1553 /*
1554 * Get info we'll need for converting data fetched from the foreign server
1555 * into local representation and error reporting during that process.
1556 */
1558 {
1561 }
1562 else
1563 {
1566 }
1570 /*
1571 * Prepare for processing of parameters used in remote query, if any.
1572 */
1578 numParams,
1583 /* Set the async-capable flag */
1585 }
1587 /*
1588 * postgresIterateForeignScan
1589 * Retrieve next row from the result set, or clear tuple slot to indicate
1590 * EOF.
1591 */
1594 {
1598 /*
1599 * In sync mode, if this is the first call after Begin or ReScan, we need
1600 * to create the cursor on the remote side. In async mode, we would have
1601 * already created the cursor before we get here, even if this is the
1602 * first call after Begin or ReScan.
1603 */
1607 /*
1608 * Get some more tuples, if we've run out.
1609 */
1611 {
1612 /* In async mode, just clear tuple slot. */
1615 /* No point in another fetch if we already detected EOF, though. */
1618 /* If we didn't get any tuples, must be end of data. */
1621 }
1623 /*
1624 * Return the next tuple.
1625 */
1627 slot,
1631 }
1633 /*
1634 * postgresReScanForeignScan
1635 * Restart the scan.
1636 */
1637 static void
1639 {
1644 /* If we haven't created the cursor yet, nothing to do. */
1648 /*
1649 * If the node is async-capable, and an asynchronous fetch for it has
1650 * begun, the asynchronous fetch might not have yet completed. Check if
1651 * the node is async-capable, and an asynchronous fetch for it is still in
1652 * progress; if so, complete the asynchronous fetch before restarting the
1653 * scan.
1654 */
1660 /*
1661 * If any internal parameters affecting this node have changed, we'd
1662 * better destroy and recreate the cursor. Otherwise, rewinding it should
1663 * be good enough. If we've only fetched zero or one batch, we needn't
1664 * even rewind the cursor, just rescan what we have.
1665 */
1667 {
1671 }
1673 {
1676 }
1677 else
1678 {
1679 /* Easy: just rescan what we already have in memory, if anything */
1682 }
1684 /*
1685 * We don't use a PG_TRY block here, so be careful not to throw error
1686 * without releasing the PGresult.
1687 */
1693 /* Now force a fresh FETCH. */
1699 }
1701 /*
1702 * postgresEndForeignScan
1703 * Finish scanning foreign table and dispose objects used for this scan
1704 */
1705 static void
1707 {
1710 /* if fsstate is NULL, we are in EXPLAIN; nothing to do */
1714 /* Close the cursor if open, to prevent accumulation of cursors */
1719 /* Release remote connection */
1723 /* MemoryContexts will be deleted automatically. */
1724 }
1726 /*
1727 * postgresAddForeignUpdateTargets
1728 * Add resjunk column(s) needed for update/delete on a foreign table
1729 */
1730 static void
1732 Index rtindex,
1734 Relation target_relation)
1735 {
1738 /*
1739 * In postgres_fdw, what we need is the ctid, same as for a regular table.
1740 */
1742 /* Make a Var representing the desired value */
1744 SelfItemPointerAttributeNumber,
1745 TIDOID,
1747 InvalidOid,
1750 /* Register it as a row-identity column needed by this target rel */
1752 }
1754 /*
1755 * postgresPlanForeignModify
1756 * Plan an insert/update/delete operation on a foreign table
1757 */
1761 Index resultRelation,
1763 {
1766 Relation rel;
1767 StringInfoData sql;
1777 /*
1778 * Core code already has some lock on each rel being planned, so we can
1779 * use NoLock here.
1780 */
1783 /*
1784 * In an INSERT, we transmit all columns that are defined in the foreign
1785 * table. In an UPDATE, if there are BEFORE ROW UPDATE triggers on the
1786 * foreign table, we transmit all columns like INSERT; else we transmit
1787 * only columns that were explicitly targets of the UPDATE, so as to avoid
1788 * unnecessary data transmission. (We can't do that for INSERT since we
1789 * would miss sending default values for columns not listed in the source
1790 * statement, and for UPDATE if there are BEFORE ROW UPDATE triggers since
1791 * those triggers might change values for non-target columns, in which
1792 * case we would miss sending changed values for those columns.)
1793 */
1798 {
1803 {
1808 }
1809 }
1811 {
1818 {
1819 /* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
1825 }
1826 }
1828 /*
1829 * Extract the relevant WITH CHECK OPTION list if any.
1830 */
1833 subplan_index);
1835 /*
1836 * Extract the relevant RETURNING list if any.
1837 */
1841 /*
1842 * ON CONFLICT DO UPDATE and DO NOTHING case with inference specification
1843 * should have already been rejected in the optimizer, as presently there
1844 * is no way to recognize an arbiter index on a foreign table. Only DO
1845 * NOTHING is supported without an inference specification.
1846 */
1853 /*
1854 * Construct the SQL command string.
1855 */
1857 {
1866 targetAttrs,
1872 returningList,
1878 }
1882 /*
1883 * Build the fdw_private list that will be available to the executor.
1884 * Items in the list must match enum FdwModifyPrivateIndex, above.
1885 */
1887 targetAttrs,
1890 retrieved_attrs);
1891 }
1893 /*
1894 * postgresBeginForeignModify
1895 * Begin an insert/update/delete operation on a foreign table
1896 */
1897 static void
1903 {
1912 /*
1913 * Do nothing in EXPLAIN (no ANALYZE) case. resultRelInfo->ri_FdwState
1914 * stays NULL.
1915 */
1919 /* Deconstruct fdw_private data. */
1921 FdwModifyPrivateUpdateSql));
1923 FdwModifyPrivateTargetAttnums);
1925 FdwModifyPrivateLen));
1927 FdwModifyPrivateHasReturning));
1929 FdwModifyPrivateRetrievedAttrs);
1931 /* Find RTE. */
1935 /* Construct an execution state. */
1937 rte,
1938 resultRelInfo,
1941 query,
1942 target_attrs,
1943 values_end_len,
1944 has_returning,
1945 retrieved_attrs);
1948 }
1950 /*
1951 * postgresExecForeignInsert
1952 * Insert one row into a foreign table
1953 */
1959 {
1964 /*
1965 * If the fmstate has aux_fmstate set, use the aux_fmstate (see
1966 * postgresBeginForeignInsert())
1967 */
1972 /* Revert that change */
1977 }
1979 /*
1980 * postgresExecForeignBatchInsert
1981 * Insert multiple rows into a foreign table
1982 */
1989 {
1993 /*
1994 * If the fmstate has aux_fmstate set, use the aux_fmstate (see
1995 * postgresBeginForeignInsert())
1996 */
2001 /* Revert that change */
2006 }
2008 /*
2009 * postgresGetForeignModifyBatchSize
2010 * Determine the maximum number of tuples that can be inserted in bulk
2011 *
2012 * Returns the batch size specified for server or table. When batching is not
2013 * allowed (e.g. for tables with BEFORE/AFTER ROW triggers or with RETURNING
2014 * clause), returns 1.
2015 */
2016 static int
2018 {
2022 /* should be called only once */
2025 /*
2026 * Should never get called when the insert is being performed on a table
2027 * that is also among the target relations of an UPDATE operation, because
2028 * postgresBeginForeignInsert() currently rejects such insert attempts.
2029 */
2032 /*
2033 * In EXPLAIN without ANALYZE, ri_FdwState is NULL, so we have to lookup
2034 * the option directly in server/table options. Otherwise just use the
2035 * value we determined earlier.
2036 */
2039 else
2042 /*
2043 * Disable batching when we have to use RETURNING, there are any
2044 * BEFORE/AFTER ROW INSERT triggers on the foreign table, or there are any
2045 * WITH CHECK OPTION constraints from parent views.
2046 *
2047 * When there are any BEFORE ROW INSERT triggers on the table, we can't
2048 * support it, because such triggers might query the table we're inserting
2049 * into and act differently if the tuples that have already been processed
2050 * and prepared for insertion are not there.
2051 */
2059 /*
2060 * If the foreign table has no columns, disable batching as the INSERT
2061 * syntax doesn't allow batching multiple empty rows into a zero-column
2062 * table in a single statement. This is needed for COPY FROM, in which
2063 * case fmstate must be non-NULL.
2064 */
2068 /*
2069 * Otherwise use the batch size specified for server/table. The number of
2070 * parameters in a batch is limited to 65535 (uint16), so make sure we
2071 * don't exceed this limit by using the maximum batch_size possible.
2072 */
2077 }
2079 /*
2080 * postgresExecForeignUpdate
2081 * Update one row in a foreign table
2082 */
2088 {
2096 }
2098 /*
2099 * postgresExecForeignDelete
2100 * Delete one row from a foreign table
2101 */
2107 {
2115 }
2117 /*
2118 * postgresEndForeignModify
2119 * Finish an insert/update/delete operation on a foreign table
2120 */
2121 static void
2124 {
2127 /* If fmstate is NULL, we are in EXPLAIN; nothing to do */
2131 /* Destroy the execution state */
2133 }
2135 /*
2136 * postgresBeginForeignInsert
2137 * Begin an insert operation on a foreign table
2138 */
2139 static void
2142 {
2146 Index resultRelation;
2152 StringInfoData sql;
2157 /*
2158 * If the foreign table we are about to insert routed rows into is also an
2159 * UPDATE subplan result rel that will be updated later, proceeding with
2160 * the INSERT will result in the later UPDATE incorrectly modifying those
2161 * routed rows, so prevent the INSERT --- it would be nice if we could
2162 * handle this case; but for now, throw an error for safety.
2163 */
2174 /* We transmit all columns that are defined in the foreign table. */
2176 {
2181 }
2183 /* Check if we add the ON CONFLICT clause to the remote query. */
2185 {
2188 /* We only support DO NOTHING without an inference specification. */
2194 }
2196 /*
2197 * If the foreign table is a partition that doesn't have a corresponding
2198 * RTE entry, we need to create a new RTE describing the foreign table for
2199 * use by deparseInsertSql and create_foreign_modify() below, after first
2200 * copying the parent's RTE and modifying some fields to describe the
2201 * foreign partition to work on. However, if this is invoked by UPDATE,
2202 * the existing RTE may already correspond to this partition if it is one
2203 * of the UPDATE subplan target rels; in that case, we can just use the
2204 * existing RTE as-is.
2205 */
2207 {
2215 /*
2216 * For UPDATE, we must use the RT index of the first subplan target
2217 * rel's RTE, because the core code would have built expressions for
2218 * the partition, such as RETURNING, using that RT index as varno of
2219 * Vars contained in those expressions.
2220 */
2224 else
2226 }
2227 else
2228 {
2231 }
2233 /* Construct the SQL command string. */
2239 /* Construct an execution state. */
2241 rte,
2242 resultRelInfo,
2243 CMD_INSERT,
2244 NULL,
2246 targetAttrs,
2247 values_end_len,
2249 retrieved_attrs);
2251 /*
2252 * If the given resultRelInfo already has PgFdwModifyState set, it means
2253 * the foreign table is an UPDATE subplan result rel; in which case, store
2254 * the resulting state into the aux_fmstate of the PgFdwModifyState.
2255 */
2257 {
2261 }
2262 else
2264 }
2266 /*
2267 * postgresEndForeignInsert
2268 * Finish an insert operation on a foreign table
2269 */
2270 static void
2273 {
2278 /*
2279 * If the fmstate has aux_fmstate set, get the aux_fmstate (see
2280 * postgresBeginForeignInsert())
2281 */
2285 /* Destroy the execution state */
2287 }
2289 /*
2290 * postgresIsForeignRelUpdatable
2291 * Determine whether a foreign table supports INSERT, UPDATE and/or
2292 * DELETE.
2293 */
2294 static int
2296 {
2302 /*
2303 * By default, all postgres_fdw foreign tables are assumed updatable. This
2304 * can be overridden by a per-server setting, which in turn can be
2305 * overridden by a per-table setting.
2306 */
2313 {
2318 }
2320 {
2325 }
2327 /*
2328 * Currently "updatable" means support for INSERT, UPDATE and DELETE.
2329 */
2332 }
2334 /*
2335 * postgresRecheckForeignScan
2336 * Execute a local join execution plan for a foreign join
2337 */
2338 static bool
2340 {
2345 /* For base foreign relations, it suffices to set fdw_recheck_quals */
2351 /* Execute a local join execution plan */
2356 /* Store result in the given slot */
2360 }
2362 /*
2363 * find_modifytable_subplan
2364 * Helper routine for postgresPlanDirectModify to find the
2365 * ModifyTable subplan node that scans the specified RTI.
2366 *
2367 * Returns NULL if the subplan couldn't be identified. That's not a fatal
2368 * error condition, we just abandon trying to do the update directly.
2369 */
2373 Index rtindex,
2375 {
2378 /*
2379 * The cases we support are (1) the desired ForeignScan is the immediate
2380 * child of ModifyTable, or (2) it is the subplan_index'th child of an
2381 * Append node that is the immediate child of ModifyTable. There is no
2382 * point in looking further down, as that would mean that local joins are
2383 * involved, so we can't do the update directly.
2384 *
2385 * There could be a Result atop the Append too, acting to compute the
2386 * UPDATE targetlist values. We ignore that here; the tlist will be
2387 * checked by our caller.
2388 *
2389 * In principle we could examine all the children of the Append, but it's
2390 * currently unlikely that the core planner would generate such a plan
2391 * with the children out-of-order. Moreover, such a search risks costing
2392 * O(N^2) time when there are a lot of children.
2393 */
2395 {
2400 }
2404 {
2409 }
2411 /* Now, have we got a ForeignScan on the desired rel? */
2413 {
2418 }
2421 }
2423 /*
2424 * postgresPlanDirectModify
2425 * Consider a direct foreign table modification
2426 *
2427 * Decide whether it is safe to modify a foreign table directly, and if so,
2428 * rewrite subplan accordingly.
2429 */
2430 static bool
2433 Index resultRelation,
2435 {
2440 Relation rel;
2441 StringInfoData sql;
2450 /*
2451 * Decide whether it is safe to modify a foreign table directly.
2452 */
2454 /*
2455 * The table modification must be an UPDATE or DELETE.
2456 */
2460 /*
2461 * Try to locate the ForeignScan subplan that's scanning resultRelation.
2462 */
2467 /*
2468 * It's unsafe to modify a foreign table directly if there are any quals
2469 * that should be evaluated locally.
2470 */
2474 /* Safe to fetch data about the target foreign rel */
2476 {
2478 /* We should have a rel for this foreign join. */
2480 }
2481 else
2486 /*
2487 * It's unsafe to update a foreign table directly, if any expressions to
2488 * assign to the target columns are unsafe to evaluate remotely.
2489 */
2491 {
2495 /*
2496 * The expressions of concern are the first N columns of the processed
2497 * targetlist, where N is the length of the rel's update_colnos.
2498 */
2502 {
2506 /* update's new-value expressions shouldn't be resjunk */
2514 }
2515 }
2517 /*
2518 * Ok, rewrite subplan so as to modify the foreign table directly.
2519 */
2522 /*
2523 * Core code already has some lock on each rel being planned, so we can
2524 * use NoLock here.
2525 */
2528 /*
2529 * Recall the qual clauses that must be evaluated remotely. (These are
2530 * bare clauses not RestrictInfos, but deparse.c's appendConditions()
2531 * doesn't care.)
2532 */
2535 /*
2536 * Extract the relevant RETURNING list if any.
2537 */
2539 {
2542 /*
2543 * When performing an UPDATE/DELETE .. RETURNING on a join directly,
2544 * we fetch from the foreign server any Vars specified in RETURNING
2545 * that refer not only to the target relation but to non-target
2546 * relations. So we'll deparse them into the RETURNING clause of the
2547 * remote query; use a targetlist consisting of them instead, which
2548 * will be adjusted to be new fdw_scan_tlist of the foreign-scan plan
2549 * node below.
2550 */
2553 returningList);
2554 }
2556 /*
2557 * Construct the SQL command string.
2558 */
2560 {
2563 foreignrel,
2564 processed_tlist,
2565 targetAttrs,
2571 foreignrel,
2578 }
2580 /*
2581 * Update the operation and target relation info.
2582 */
2586 /*
2587 * Update the fdw_exprs list that will be available to the executor.
2588 */
2591 /*
2592 * Update the fdw_private list that will be available to the executor.
2593 * Items in the list must match enum FdwDirectModifyPrivateIndex, above.
2594 */
2597 retrieved_attrs,
2600 /*
2601 * Update the foreign-join-related fields.
2602 */
2604 {
2605 /* No need for the outer subplan. */
2608 /* Build new fdw_scan_tlist if UPDATE/DELETE .. RETURNING. */
2611 }
2613 /*
2614 * Finally, unset the async-capable flag if it is set, as we currently
2615 * don't support asynchronous execution of direct modifications.
2616 */
2622 }
2624 /*
2625 * postgresBeginDirectModify
2626 * Prepare a direct foreign table modification
2627 */
2628 static void
2630 {
2634 Index rtindex;
2635 Oid userid;
2640 /*
2641 * Do nothing in EXPLAIN (no ANALYZE) case. node->fdw_state stays NULL.
2642 */
2646 /*
2647 * We'll save private state in node->fdw_state.
2648 */
2652 /*
2653 * Identify which user to do the remote access as. This should match what
2654 * ExecCheckPermissions() does.
2655 */
2658 /* Get info about foreign table. */
2662 else
2667 /*
2668 * Get connection to the foreign server. Connection manager will
2669 * establish new connection if necessary.
2670 */
2673 /* Update the foreign-join-related fields. */
2675 {
2676 /* Save info about foreign table. */
2679 /*
2680 * Set dmstate->rel to NULL to teach get_returning_data() and
2681 * make_tuple_from_result_row() that columns fetched from the remote
2682 * server are described by fdw_scan_tlist of the foreign-scan plan
2683 * node, not the tuple descriptor for the target relation.
2684 */
2686 }
2688 /* Initialize state variable */
2691 /* Get private info created by planner functions. */
2693 FdwDirectModifyPrivateUpdateSql));
2695 FdwDirectModifyPrivateHasReturning));
2697 FdwDirectModifyPrivateRetrievedAttrs);
2699 FdwDirectModifyPrivateSetProcessed));
2701 /* Create context for per-tuple temp workspace. */
2704 ALLOCSET_SMALL_SIZES);
2706 /* Prepare for input conversion of RETURNING results. */
2708 {
2709 TupleDesc tupdesc;
2713 else
2718 /*
2719 * When performing an UPDATE/DELETE .. RETURNING on a join directly,
2720 * initialize a filter to extract an updated/deleted tuple from a scan
2721 * tuple.
2722 */
2725 }
2727 /*
2728 * Prepare for processing of parameters used in remote query, if any.
2729 */
2735 numParams,
2739 }
2741 /*
2742 * postgresIterateDirectModify
2743 * Execute a direct foreign table modification
2744 */
2747 {
2752 /*
2753 * If this is the first call after Begin, execute the statement.
2754 */
2758 /*
2759 * If the local query doesn't specify RETURNING, just clear tuple slot.
2760 */
2762 {
2768 /* Increment the command es_processed count if necessary. */
2772 /* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
2777 }
2779 /*
2780 * Get the next RETURNING tuple.
2781 */
2783 }
2785 /*
2786 * postgresEndDirectModify
2787 * Finish a direct foreign table modification
2788 */
2789 static void
2791 {
2794 /* if dmstate is NULL, we are in EXPLAIN; nothing to do */
2798 /* Release PGresult */
2801 /* Release remote connection */
2805 /* MemoryContext will be deleted automatically. */
2806 }
2808 /*
2809 * postgresExplainForeignScan
2810 * Produce extra output for EXPLAIN of a ForeignScan on a foreign table
2811 */
2812 static void
2814 {
2818 /*
2819 * Identify foreign scans that are really joins or upper relations. The
2820 * input looks something like "(1) LEFT JOIN (2)", and we must replace the
2821 * digit string(s), which are RT indexes, with the correct relation names.
2822 * We do that here, not when the plan is created, because we can't know
2823 * what aliases ruleutils.c will assign at plan creation time.
2824 */
2826 {
2827 StringInfo relations;
2831 rtoffset;
2835 /*
2836 * A difficulty with using a string representation of RT indexes is
2837 * that setrefs.c won't update the string when flattening the
2838 * rangetable. To find out what rtoffset was applied, identify the
2839 * minimum RT index appearing in the string and compare it to the
2840 * minimum member of plan->fs_base_relids. (We expect all the relids
2841 * in the join will have been offset by the same amount; the Asserts
2842 * below should catch it if that ever changes.)
2843 */
2847 {
2849 {
2854 }
2855 else
2856 ptr++;
2857 }
2860 /* Now we can translate the string */
2864 {
2866 {
2876 /* This logic should agree with explain.c's ExplainTargetRel */
2879 {
2886 }
2887 else
2896 }
2897 else
2899 }
2901 }
2903 /*
2904 * Add remote query, when VERBOSE option is specified.
2905 */
2907 {
2912 }
2913 }
2915 /*
2916 * postgresExplainForeignModify
2917 * Produce extra output for EXPLAIN of a ModifyTable on a foreign table
2918 */
2919 static void
2925 {
2927 {
2929 FdwModifyPrivateUpdateSql));
2933 /*
2934 * For INSERT we should always have batch size >= 1, but UPDATE and
2935 * DELETE don't support batching so don't show the property.
2936 */
2939 }
2940 }
2942 /*
2943 * postgresExplainDirectModify
2944 * Produce extra output for EXPLAIN of a ForeignScan that modifies a
2945 * foreign table directly
2946 */
2947 static void
2949 {
2954 {
2958 }
2959 }
2961 /*
2962 * postgresExecForeignTruncate
2963 * Truncate one or more foreign tables
2964 */
2965 static void
2967 DropBehavior behavior,
2969 {
2973 StringInfoData sql;
2977 /*
2978 * By default, all postgres_fdw foreign tables are assumed truncatable.
2979 * This can be overridden by a per-server setting, which in turn can be
2980 * overridden by a per-table setting.
2981 */
2983 {
2990 /*
2991 * First time through, determine whether the foreign server allows
2992 * truncates. Since all specified foreign tables are assumed to belong
2993 * to the same foreign server, this result can be used for other
2994 * foreign tables.
2995 */
2997 {
3002 {
3006 {
3009 }
3010 }
3011 }
3013 /*
3014 * Confirm that all specified foreign tables belong to the same
3015 * foreign server.
3016 */
3019 /* Determine whether this foreign table allows truncations */
3022 {
3026 {
3029 }
3030 }
3037 }
3040 /*
3041 * Get connection to the foreign server. Connection manager will
3042 * establish new connection if necessary.
3043 */
3047 /* Construct the TRUNCATE command string */
3051 /* Issue the TRUNCATE command to remote server */
3055 }
3057 /*
3058 * estimate_path_cost_size
3059 * Get cost and size estimates for a foreign scan on given foreign relation
3060 * either a base relation or a join between foreign relations or an upper
3061 * relation containing foreign relations.
3062 *
3063 * param_join_conds are the parameterization clauses with outer relations.
3064 * pathkeys specify the expected sort order if any for given path being costed.
3065 * fpextra specifies additional post-scan/join-processing steps such as the
3066 * final sort and the LIMIT restriction.
3067 *
3068 * The function returns the cost and size estimates in p_rows, p_width,
3069 * p_startup_cost and p_total_cost variables.
3070 */
3071 static void
3079 {
3084 Cost startup_cost;
3085 Cost total_cost;
3087 /* Make sure the core code has set up the relation's reltarget */
3090 /*
3091 * If the table or the server is configured to use remote estimates,
3092 * connect to the foreign server and execute EXPLAIN to estimate the
3093 * number of rows selected by the restriction+join clauses. Otherwise,
3094 * estimate rows using whatever statistics we have locally, in a way
3095 * similar to ordinary tables.
3096 */
3098 {
3101 StringInfoData sql;
3103 Selectivity local_sel;
3104 QualCost local_cost;
3108 /* Required only to be passed to deparseSelectStmtForRel */
3111 /*
3112 * param_join_conds might contain both clauses that are safe to send
3113 * across, and clauses that aren't.
3114 */
3118 /* Build the list of columns to be fetched from the foreign server. */
3121 else
3124 /*
3125 * The complete list of remote conditions includes everything from
3126 * baserestrictinfo plus any extra join_conds relevant to this
3127 * particular path.
3128 */
3132 /*
3133 * Construct EXPLAIN query including the desired SELECT, FROM, and
3134 * WHERE clauses. Params and other-relation Vars are replaced by dummy
3135 * values, so don't request params_list.
3136 */
3145 /* Get the remote estimate */
3153 /* Factor in the selectivity of the locally-checked quals */
3155 local_param_join_conds,
3157 JOIN_INNER,
3158 NULL);
3163 /* Add in the eval cost of the locally-checked quals */
3170 /*
3171 * Add in tlist eval cost for each output row. In case of an
3172 * aggregate, some of the tlist expressions such as grouping
3173 * expressions will be evaluated remotely, so adjust the costs.
3174 */
3179 {
3180 QualCost tlist_cost;
3186 }
3187 }
3188 else
3189 {
3192 /*
3193 * We don't support join conditions in this mode (hence, no
3194 * parameterized paths can be made).
3195 */
3198 /*
3199 * We will come here again and again with different set of pathkeys or
3200 * additional post-scan/join-processing steps that caller wants to
3201 * cost. We don't need to calculate the cost/size estimates for the
3202 * underlying scan, join, or grouping each time. Instead, use those
3203 * estimates if we have cached them already.
3204 */
3206 {
3215 /*
3216 * If we estimate the costs of a foreign scan or a foreign join
3217 * with additional post-scan/join-processing steps, the scan or
3218 * join costs obtained from the cache wouldn't yet contain the
3219 * eval costs for the final scan/join target, which would've been
3220 * updated by apply_scanjoin_target_to_paths(); add the eval costs
3221 * now.
3222 */
3224 {
3225 /* Shouldn't get here unless we have LIMIT */
3231 }
3232 }
3234 {
3237 QualCost join_cost;
3238 QualCost remote_conds_cost;
3241 /* Use rows/width estimates made by the core code. */
3245 /* For join we expect inner and outer relations set */
3251 /* Estimate of number of rows in cross product */
3254 /*
3255 * Back into an estimate of the number of retrieved rows. Just in
3256 * case this is nuts, clamp to at most nrows.
3257 */
3261 /*
3262 * The cost of foreign join is estimated as cost of generating
3263 * rows for the joining relations + cost for applying quals on the
3264 * rows.
3265 */
3267 /*
3268 * Calculate the cost of clauses pushed down to the foreign server
3269 */
3271 /* Calculate the cost of applying join clauses */
3274 /*
3275 * Startup cost includes startup cost of joining relations and the
3276 * startup cost for join and other clauses. We do not include the
3277 * startup cost specific to join strategy (e.g. setting up hash
3278 * tables) since we do not know what strategy the foreign server
3279 * is going to use.
3280 */
3286 /*
3287 * Run time cost includes:
3288 *
3289 * 1. Run time cost (total_cost - startup_cost) of relations being
3290 * joined
3291 *
3292 * 2. Run time cost of applying join clauses on the cross product
3293 * of the joining relations.
3294 *
3295 * 3. Run time cost of applying pushed down other clauses on the
3296 * result of join
3297 *
3298 * 4. Run time cost of applying nonpushable other clauses locally
3299 * on the result fetched from the foreign server.
3300 */
3308 /* Add in tlist eval cost for each output row */
3311 }
3313 {
3316 AggClauseCosts aggcosts;
3321 /* The upper relation should have its outer relation set */
3323 /* and that outer relation should have its reltarget set */
3326 /*
3327 * This cost model is mixture of costing done for sorted and
3328 * hashed aggregates in cost_agg(). We are not sure which
3329 * strategy will be considered at remote side, thus for
3330 * simplicity, we put all startup related costs in startup_cost
3331 * and all finalization and run cost are added in total_cost.
3332 */
3336 /* Get rows from input rel */
3339 /* Collect statistics about aggregates for estimating costs. */
3342 {
3344 }
3346 /* Get number of grouping columns and possible number of groups */
3353 /*
3354 * Get the retrieved_rows and rows estimates. If there are HAVING
3355 * quals, account for their selectivity.
3356 */
3358 {
3359 /* Factor in the selectivity of the remotely-checked quals */
3360 retrieved_rows =
3365 JOIN_INNER,
3366 NULL));
3367 /* Factor in the selectivity of the locally-checked quals */
3369 }
3370 else
3371 {
3373 }
3375 /* Use width estimate made by the core code. */
3378 /*-----
3379 * Startup cost includes:
3380 * 1. Startup cost for underneath input relation, adjusted for
3381 * tlist replacement by apply_scanjoin_target_to_paths()
3382 * 2. Cost of performing aggregation, per cost_agg()
3383 *-----
3384 */
3392 /*-----
3393 * Run time cost includes:
3394 * 1. Run time cost of underneath input relation, adjusted for
3395 * tlist replacement by apply_scanjoin_target_to_paths()
3396 * 2. Run time cost of performing aggregation, per cost_agg()
3397 *-----
3398 */
3404 /* Account for the eval cost of HAVING quals, if any */
3406 {
3407 QualCost remote_cost;
3409 /* Add in the eval cost of the remotely-checked quals */
3413 /* Add in the eval cost of the locally-checked quals */
3416 }
3418 /* Add in tlist eval cost for each output row */
3421 }
3422 else
3423 {
3424 Cost cpu_per_tuple;
3426 /* Use rows/width estimates made by set_baserel_size_estimates. */
3430 /*
3431 * Back into an estimate of the number of retrieved rows. Just in
3432 * case this is nuts, clamp to at most foreignrel->tuples.
3433 */
3437 /*
3438 * Cost as though this were a seqscan, which is pessimistic. We
3439 * effectively imagine the local_conds are being evaluated
3440 * remotely, too.
3441 */
3450 /* Add in tlist eval cost for each output row */
3453 }
3455 /*
3456 * Without remote estimates, we have no real way to estimate the cost
3457 * of generating sorted output. It could be free if the query plan
3458 * the remote side would have chosen generates properly-sorted output
3459 * anyway, but in most cases it will cost something. Estimate a value
3460 * high enough that we won't pick the sorted path when the ordering
3461 * isn't locally useful, but low enough that we'll err on the side of
3462 * pushing down the ORDER BY clause when it's useful to do so.
3463 */
3465 {
3467 {
3474 }
3475 else
3476 {
3479 }
3480 }
3484 /* Adjust the cost estimates if we have LIMIT */
3486 {
3490 }
3491 }
3493 /*
3494 * If this includes the final sort step, the given target, which will be
3495 * applied to the resulting path, might have different expressions from
3496 * the foreignrel's reltarget (see make_sort_input_target()); adjust tlist
3497 * eval costs.
3498 */
3501 {
3508 }
3510 /*
3511 * Cache the retrieved rows and cost estimates for scans, joins, or
3512 * groupings without any parameterization, pathkeys, or additional
3513 * post-scan/join-processing steps, before adding the costs for
3514 * transferring data from the foreign server. These estimates are useful
3515 * for costing remote joins involving this relation or costing other
3516 * remote operations on this relation such as remote sorts and remote
3517 * LIMIT restrictions, when the costs can not be obtained from the foreign
3518 * server. This function will be called at least once for every foreign
3519 * relation without any parameterization, pathkeys, or additional
3520 * post-scan/join-processing steps.
3521 */
3523 {
3527 }
3529 /*
3530 * Add some additional cost factors to account for connection overhead
3531 * (fdw_startup_cost), transferring data across the network
3532 * (fdw_tuple_cost per retrieved row), and local manipulation of the data
3533 * (cpu_tuple_cost per retrieved row).
3534 */
3540 /*
3541 * If we have LIMIT, we should prefer performing the restriction remotely
3542 * rather than locally, as the former avoids extra row fetches from the
3543 * remote that the latter might cause. But since the core code doesn't
3544 * account for such fetches when estimating the costs of the local
3545 * restriction (see create_limit_path()), there would be no difference
3546 * between the costs of the local restriction and the costs of the remote
3547 * restriction estimated above if we don't use remote estimates (except
3548 * for the case where the foreignrel is a grouping relation, the given
3549 * pathkeys is not NIL, and the effects of a bounded sort for that rel is
3550 * accounted for in costing the remote restriction). Tweak the costs of
3551 * the remote restriction to ensure we'll prefer it if LIMIT is a useful
3552 * one.
3553 */
3558 {
3562 }
3564 /* Return results. */
3569 }
3571 /*
3572 * Estimate costs of executing a SQL statement remotely.
3573 * The given "sql" must be an EXPLAIN command.
3574 */
3575 static void
3579 {
3582 /* PGresult must be released before leaving this function. */
3584 {
3589 /*
3590 * Execute EXPLAIN remotely.
3591 */
3596 /*
3597 * Extract cost numbers for topmost plan node. Note we search for a
3598 * left paren from the end of the line to avoid being confused by
3599 * other uses of parentheses.
3600 */
3609 }
3611 {
3613 }
3615 }
3617 /*
3618 * Adjust the cost estimates of a foreign grouping path to include the cost of
3619 * generating properly-sorted output.
3620 */
3621 static void
3629 {
3630 /*
3631 * If the GROUP BY clause isn't sort-able, the plan chosen by the remote
3632 * side is unlikely to generate properly-sorted output, so it would need
3633 * an explicit sort; adjust the given costs with cost_sort(). Likewise,
3634 * if the GROUP BY clause is sort-able but isn't a superset of the given
3635 * pathkeys, adjust the costs with that function. Otherwise, adjust the
3636 * costs by applying the same heuristic as for the scan or join case.
3637 */
3640 {
3644 root,
3645 pathkeys,
3647 retrieved_rows,
3648 width,
3650 work_mem,
3651 limit_tuples);
3655 }
3656 else
3657 {
3658 /*
3659 * The default extra cost seems too large for foreign-grouping cases;
3660 * add 1/4th of that default.
3661 */
3667 }
3668 }
3670 /*
3671 * Detect whether we want to process an EquivalenceClass member.
3672 *
3673 * This is a callback for use by generate_implied_equalities_for_column.
3674 */
3675 static bool
3679 {
3683 /*
3684 * If we've identified what we're processing in the current scan, we only
3685 * want to match that expression.
3686 */
3690 /*
3691 * Otherwise, ignore anything we've already processed.
3692 */
3696 /* This is the new target to process. */
3699 }
3701 /*
3702 * Create cursor for node's query with current parameter values.
3703 */
3704 static void
3706 {
3712 StringInfoData buf;
3715 /* First, process a pending asynchronous request, if any. */
3719 /*
3720 * Construct array of query parameter values in text format. We do the
3721 * conversions in the short-lived per-tuple context, so as not to cause a
3722 * memory leak over repeated scans.
3723 */
3725 {
3726 MemoryContext oldcontext;
3733 values);
3736 }
3738 /* Construct the DECLARE CURSOR command */
3743 /*
3744 * Notice that we pass NULL for paramTypes, thus forcing the remote server
3745 * to infer types for all parameters. Since we explicitly cast every
3746 * parameter (see deparse.c), the "inference" is trivial and will produce
3747 * the desired result. This allows us to avoid assuming that the remote
3748 * server has the same OIDs we do for the parameters' types.
3749 */
3754 /*
3755 * Get the result, and check for success.
3756 *
3757 * We don't use a PG_TRY block here, so be careful not to throw error
3758 * without releasing the PGresult.
3759 */
3765 /* Mark the cursor as created, and show no tuples have been retrieved */
3773 /* Clean up */
3775 }
3777 /*
3778 * Fetch some more rows from the node's cursor.
3779 */
3780 static void
3782 {
3785 MemoryContext oldcontext;
3787 /*
3788 * We'll store the tuples in the batch_cxt. First, flush the previous
3789 * batch.
3790 */
3795 /* PGresult must be released before leaving this function. */
3797 {
3803 {
3806 /*
3807 * The query was already sent by an earlier call to
3808 * fetch_more_data_begin. So now we just fetch the result.
3809 */
3811 /* On error, report the original query, not the FETCH. */
3815 /* Reset per-connection state */
3817 }
3818 else
3819 {
3822 /* This is a regular synchronous fetch. */
3827 /* On error, report the original query, not the FETCH. */
3830 }
3832 /* Convert the data into HeapTuples */
3839 {
3847 node,
3849 }
3851 /* Update fetch_ct_2 */
3855 /* Must be EOF if we didn't get as many tuples as we asked for. */
3857 }
3859 {
3861 }
3865 }
3867 /*
3868 * Force assorted GUC parameters to settings that ensure that we'll output
3869 * data values in a form that is unambiguous to the remote server.
3870 *
3871 * This is rather expensive and annoying to do once per row, but there's
3872 * little choice if we want to be sure values are transmitted accurately;
3873 * we can't leave the settings in place between rows for fear of affecting
3874 * user-visible computations.
3875 *
3876 * We use the equivalent of a function SET option to allow the settings to
3877 * persist only until the caller calls reset_transmission_modes(). If an
3878 * error is thrown in between, guc.c will take care of undoing the settings.
3879 *
3880 * The return value is the nestlevel that must be passed to
3881 * reset_transmission_modes() to undo things.
3882 */
3883 int
3885 {
3888 /*
3889 * The values set here should match what pg_dump does. See also
3890 * configure_remote_session in connection.c.
3891 */
3905 /*
3906 * In addition force restrictive search_path, in case there are any
3907 * regproc or similar constants to be printed.
3908 */
3914 }
3916 /*
3917 * Undo the effects of set_transmission_modes().
3918 */
3919 void
3921 {
3923 }
3925 /*
3926 * Utility routine to close a cursor.
3927 */
3928 static void
3931 {
3937 /*
3938 * We don't use a PG_TRY block here, so be careful not to throw error
3939 * without releasing the PGresult.
3940 */
3945 }
3947 /*
3948 * create_foreign_modify
3949 * Construct an execution state of a foreign insert/update/delete
3950 * operation
3951 */
3956 CmdType operation,
3963 {
3967 Oid userid;
3970 AttrNumber n_params;
3971 Oid typefnoid;
3975 /* Begin constructing PgFdwModifyState. */
3979 /* Identify which user to do the remote access as. */
3982 /* Get info about foreign table. */
3986 /* Open connection; report that we'll create a prepared statement. */
3990 /* Set up remote query information. */
3993 {
3996 }
4002 /* Create context for per-tuple temp workspace. */
4005 ALLOCSET_SMALL_SIZES);
4007 /* Prepare for input conversion of RETURNING results. */
4011 /* Prepare for output conversion of parameters used in prepared stmt. */
4017 {
4020 /* Find the ctid resjunk column in the subplan's result */
4026 /* First transmittable parameter will be ctid */
4030 }
4033 {
4034 /* Set up for remaining transmittable parameters */
4036 {
4042 /* Ignore generated columns; they are set to DEFAULT */
4048 }
4049 }
4053 /* Set batch_size from foreign server/table options. */
4059 /* Initialize auxiliary state */
4063 }
4065 /*
4066 * execute_foreign_modify
4067 * Perform foreign-table modification as required, and fetch RETURNING
4068 * result if any. (This is the shared guts of postgresExecForeignInsert,
4069 * postgresExecForeignBatchInsert, postgresExecForeignUpdate, and
4070 * postgresExecForeignDelete.)
4071 */
4075 CmdType operation,
4079 {
4085 StringInfoData sql;
4087 /* The operation should be INSERT, UPDATE, or DELETE */
4092 /* First, process a pending asynchronous request, if any. */
4096 /*
4097 * If the existing query was deparsed and prepared for a different number
4098 * of rows, rebuild it for the proper number.
4099 */
4101 {
4102 /* Destroy the prepared statement created previously */
4106 /* Build INSERT string with numSlots records in its VALUES clause. */
4115 }
4117 /* Set up the prepared statement on the remote server, if we didn't yet */
4121 /*
4122 * For UPDATE/DELETE, get the ctid that was passed up as a resjunk column
4123 */
4125 {
4126 Datum datum;
4132 /* shouldn't ever get a null result... */
4136 }
4138 /* Convert parameters needed by prepared statement to text form */
4141 /*
4142 * Execute the prepared statement.
4143 */
4147 p_values,
4148 NULL,
4149 NULL,
4153 /*
4154 * Get the result, and check for success.
4155 *
4156 * We don't use a PG_TRY block here, so be careful not to throw error
4157 * without releasing the PGresult.
4158 */
4164 /* Check number of rows affected, and fetch RETURNING tuple if any */
4166 {
4171 }
4172 else
4175 /* And clean up */
4182 /*
4183 * Return NULL if nothing was inserted/updated/deleted on the remote end
4184 */
4186 }
4188 /*
4189 * prepare_foreign_modify
4190 * Establish a prepared statement for execution of INSERT/UPDATE/DELETE
4191 */
4192 static void
4194 {
4199 /*
4200 * The caller would already have processed a pending asynchronous request
4201 * if any, so no need to do it here.
4202 */
4204 /* Construct name we'll use for the prepared statement. */
4209 /*
4210 * We intentionally do not specify parameter types here, but leave the
4211 * remote server to derive them by default. This avoids possible problems
4212 * with the remote server using different type OIDs than we do. All of
4213 * the prepared statements we use in this module are simple enough that
4214 * the remote server will make the right choices.
4215 */
4217 p_name,
4220 NULL))
4223 /*
4224 * Get the result, and check for success.
4225 *
4226 * We don't use a PG_TRY block here, so be careful not to throw error
4227 * without releasing the PGresult.
4228 */
4234 /* This action shows that the prepare has been done. */
4236 }
4238 /*
4239 * convert_prep_stmt_params
4240 * Create array of text strings representing parameter values
4241 *
4242 * tupleid is ctid to send, or NULL if none
4243 * slot is slot to get remaining parameters from, or NULL if none
4244 *
4245 * Data is constructed in temp_cxt; caller should reset that after use.
4246 */
4249 ItemPointer tupleid,
4252 {
4257 MemoryContext oldcontext;
4263 /* ctid is provided only for UPDATE/DELETE, which don't allow batching */
4266 /* 1st parameter should be ctid, if it's in use */
4268 {
4270 /* don't need set_transmission_modes for TID output */
4273 pindex++;
4274 }
4276 /* get following parameters from slots */
4278 {
4286 {
4289 {
4292 Datum value;
4295 /* Ignore generated columns; they are set to DEFAULT */
4301 else
4303 value);
4304 pindex++;
4305 j++;
4306 }
4307 }
4310 }
4317 }
4319 /*
4320 * store_returning_result
4321 * Store the result of a RETURNING clause
4322 *
4323 * On error, be sure to release the PGresult on the way out. Callers do not
4324 * have PG_TRY blocks to ensure this happens.
4325 */
4326 static void
4329 {
4331 {
4332 HeapTuple newtup;
4338 NULL,
4341 /*
4342 * The returning slot will not necessarily be suitable to store
4343 * heaptuples directly, so allow for conversion.
4344 */
4346 }
4348 {
4351 }
4353 }
4355 /*
4356 * finish_foreign_modify
4357 * Release resources for a foreign insert/update/delete operation
4358 */
4359 static void
4361 {
4364 /* If we created a prepared statement, destroy it */
4367 /* Release remote connection */
4370 }
4372 /*
4373 * deallocate_query
4374 * Deallocate a prepared statement for a foreign insert/update/delete
4375 * operation
4376 */
4377 static void
4379 {
4383 /* do nothing if the query is not allocated */
4389 /*
4390 * We don't use a PG_TRY block here, so be careful not to throw error
4391 * without releasing the PGresult.
4392 */
4399 }
4401 /*
4402 * build_remote_returning
4403 * Build a RETURNING targetlist of a remote query for performing an
4404 * UPDATE/DELETE .. RETURNING on a join directly
4405 */
4408 {
4418 /*
4419 * If there's a whole-row reference to the target relation, then we'll
4420 * need all the columns of the relation.
4421 */
4423 {
4429 {
4432 }
4433 }
4436 {
4441 {
4445 /* Ignore dropped attributes. */
4450 i,
4459 NULL,
4461 }
4462 }
4464 /* Now add any remaining columns to tlist. */
4466 {
4469 /*
4470 * No need for whole-row references to the target relation. We don't
4471 * need system columns other than ctid and oid either, since those are
4472 * set locally.
4473 */
4486 NULL,
4488 }
4493 }
4495 /*
4496 * rebuild_fdw_scan_tlist
4497 * Build new fdw_scan_tlist of given foreign-scan plan node from given
4498 * tlist
4499 *
4500 * There might be columns that the fdw_scan_tlist of the given foreign-scan
4501 * plan node contains that the given tlist doesn't. The fdw_scan_tlist would
4502 * have contained resjunk columns such as 'ctid' of the target relation and
4503 * 'wholerow' of non-target relations, but the tlist might not contain them,
4504 * for example. So, adjust the tlist so it contains all the columns specified
4505 * in the fdw_scan_tlist; else setrefs.c will get confused.
4506 */
4507 static void
4509 {
4515 {
4524 NULL,
4526 }
4528 }
4530 /*
4531 * Execute a direct UPDATE/DELETE statement.
4532 */
4533 static void
4535 {
4541 /* First, process a pending asynchronous request, if any. */
4545 /*
4546 * Construct array of query parameter values in text format.
4547 */
4552 values);
4554 /*
4555 * Notice that we pass NULL for paramTypes, thus forcing the remote server
4556 * to infer types for all parameters. Since we explicitly cast every
4557 * parameter (see deparse.c), the "inference" is trivial and will produce
4558 * the desired result. This allows us to avoid assuming that the remote
4559 * server has the same OIDs we do for the parameters' types.
4560 */
4565 /*
4566 * Get the result, and check for success.
4567 *
4568 * We don't use a PG_TRY block here, so be careful not to throw error
4569 * without releasing the PGresult.
4570 */
4577 /* Get the number of rows affected. */
4580 else
4582 }
4584 /*
4585 * Get the result of a RETURNING clause.
4586 */
4589 {
4598 /* If we didn't get any tuples, must be end of data. */
4602 /* Increment the command es_processed count if necessary. */
4606 /*
4607 * Store a RETURNING tuple. If has_returning is false, just emit a dummy
4608 * tuple. (has_returning is false when the local query is of the form
4609 * "UPDATE/DELETE .. RETURNING 1" for example.)
4610 */
4612 {
4615 }
4616 else
4617 {
4618 /*
4619 * On error, be sure to release the PGresult on the way out. Callers
4620 * do not have PG_TRY blocks to ensure this happens.
4621 */
4623 {
4624 HeapTuple newtup;
4631 node,
4634 }
4636 {
4639 }
4642 /* Get the updated/deleted tuple. */
4645 else
4647 }
4650 /* Make slot available for evaluation of the local query RETURNING list. */
4652 resultSlot;
4655 }
4657 /*
4658 * Initialize a filter to extract an updated/deleted tuple from a scan tuple.
4659 */
4660 static void
4663 Index rtindex)
4664 {
4669 /*
4670 * Calculate the mapping between the fdw_scan_tlist's entries and the
4671 * result tuple's attributes.
4672 *
4673 * The "map" is an array of indexes of the result tuple's attributes in
4674 * fdw_scan_tlist, i.e., one entry for every attribute of the result
4675 * tuple. We store zero for any attributes that don't have the
4676 * corresponding entries in that list, marking that a NULL is needed in
4677 * the result tuple.
4678 *
4679 * Also get the indexes of the entries for ctid and oid if any.
4680 */
4689 {
4695 /*
4696 * If the Var is a column of the target relation to be retrieved from
4697 * the foreign server, get the index of the entry.
4698 */
4701 {
4705 {
4706 /*
4707 * We don't retrieve system columns other than ctid and oid.
4708 */
4711 else
4714 }
4715 else
4716 {
4717 /*
4718 * We don't retrieve whole-row references to the target
4719 * relation either.
4720 */
4724 }
4725 }
4726 i++;
4727 }
4728 }
4730 /*
4731 * Extract and return an updated/deleted tuple from a scan tuple.
4732 */
4738 {
4747 /*
4748 * Use the return tuple slot as a place to store the result tuple.
4749 */
4752 /*
4753 * Extract all the values of the scan tuple.
4754 */
4759 /*
4760 * Prepare to build the result tuple.
4761 */
4766 /*
4767 * Transpose data into proper fields of the result tuple.
4768 */
4770 {
4774 {
4777 }
4778 else
4779 {
4782 }
4783 }
4785 /*
4786 * Build the virtual tuple.
4787 */
4790 /*
4791 * If we have any system columns to return, materialize a heap tuple in
4792 * the slot from column values set above and install system columns in
4793 * that tuple.
4794 */
4796 {
4799 /* ctid */
4801 {
4806 }
4808 /*
4809 * And remaining columns
4810 *
4811 * Note: since we currently don't allow the target relation to appear
4812 * on the nullable side of an outer join, any system columns wouldn't
4813 * go to NULL.
4814 *
4815 * Note: no need to care about tableoid here because it will be
4816 * initialized in ExecProcessReturning().
4817 */
4821 }
4823 /*
4824 * And return the result tuple.
4825 */
4827 }
4829 /*
4830 * Prepare for processing of parameters used in remote query.
4831 */
4832 static void
4839 {
4845 /* Prepare for output conversion of parameters used in remote query. */
4850 {
4852 Oid typefnoid;
4857 i++;
4858 }
4860 /*
4861 * Prepare remote-parameter expressions for evaluation. (Note: in
4862 * practice, we expect that all these expressions will be just Params, so
4863 * we could possibly do something more efficient than using the full
4864 * expression-eval machinery for this. But probably there would be little
4865 * benefit, and it'd require postgres_fdw to know more than is desirable
4866 * about Param evaluation.)
4867 */
4870 /* Allocate buffer for text form of query parameters. */
4872 }
4874 /*
4875 * Construct array of query parameter values in text format.
4876 */
4877 static void
4882 {
4891 {
4893 Datum expr_value;
4896 /* Evaluate the parameter expression */
4899 /*
4900 * Get string representation of each parameter value by invoking
4901 * type-specific output function, unless the value is null.
4902 */
4905 else
4908 i++;
4909 }
4912 }
4914 /*
4915 * postgresAnalyzeForeignTable
4916 * Test whether analyzing this foreign table is supported
4917 */
4918 static bool
4922 {
4926 StringInfoData sql;
4929 /* Return the row-analysis function pointer */
4932 /*
4933 * Now we have to get the number of pages. It's annoying that the ANALYZE
4934 * API requires us to return that now, because it forces some duplication
4935 * of effort between this routine and postgresAcquireSampleRowsFunc. But
4936 * it's probably not worth redefining that API at this point.
4937 */
4939 /*
4940 * Get the connection to use. We do the remote access as the table's
4941 * owner, even if the ANALYZE was started by some other user.
4942 */
4947 /*
4948 * Construct command to get page count for relation.
4949 */
4953 /* In what follows, do not risk leaking any PGresults. */
4955 {
4963 }
4965 {
4967 }
4973 }
4975 /*
4976 * postgresGetAnalyzeInfoForForeignTable
4977 * Count tuples in foreign table (just get pg_class.reltuples).
4978 *
4979 * can_tablesample determines if the remote relation supports acquiring the
4980 * sample using TABLESAMPLE.
4981 */
4982 static double
4984 {
4988 StringInfoData sql;
4993 /* assume the remote relation does not support TABLESAMPLE */
4996 /*
4997 * Get the connection to use. We do the remote access as the table's
4998 * owner, even if the ANALYZE was started by some other user.
4999 */
5004 /*
5005 * Construct command to get page count for relation.
5006 */
5010 /* In what follows, do not risk leaking any PGresults. */
5012 {
5021 }
5023 {
5026 }
5031 /* TABLESAMPLE is supported only for regular tables and matviews */
5037 }
5039 /*
5040 * Acquire a random sample of rows from foreign table managed by postgres_fdw.
5041 *
5042 * Selected rows are returned in the caller-allocated array rows[],
5043 * which must have at least targrows entries.
5044 * The actual number of rows selected is returned as the function result.
5045 * We also count the total number of rows in the table and return it into
5046 * *totalrows. Note that *totaldeadrows is always set to 0.
5047 *
5048 * Note that the returned list of rows is not always in order by physical
5049 * position in the table. Therefore, correlation estimates derived later
5050 * may be meaningless, but it's OK because we don't use the estimates
5051 * currently (the planner only pays attention to correlation for indexscans).
5052 */
5053 static int
5058 {
5059 PgFdwAnalyzeState astate;
5069 StringInfoData sql;
5073 /* Initialize workspace state */
5084 /* Remember ANALYZE context, and create a per-tuple temp context */
5088 ALLOCSET_SMALL_SIZES);
5090 /*
5091 * Get the connection to use. We do the remote access as the table's
5092 * owner, even if the ANALYZE was started by some other user.
5093 */
5099 /* We'll need server version, so fetch it now. */
5102 /*
5103 * What sampling method should we use?
5104 */
5106 {
5110 {
5125 }
5126 }
5129 {
5133 {
5148 }
5149 }
5151 /*
5152 * Error-out if explicitly required one of the TABLESAMPLE methods, but
5153 * the server does not support it.
5154 */
5162 /*
5163 * If we've decided to do remote sampling, calculate the sampling rate. We
5164 * need to get the number of tuples from the remote server, but skip that
5165 * network round-trip if not needed.
5166 */
5168 {
5174 /*
5175 * Make sure we're not choosing TABLESAMPLE when the remote relation
5176 * does not support that. But only do this for "auto" - if the user
5177 * explicitly requested BERNOULLI/SYSTEM, it's better to fail.
5178 */
5182 /*
5183 * Remote's reltuples could be 0 or -1 if the table has never been
5184 * vacuumed/analyzed. In that case, disable sampling after all.
5185 */
5188 else
5189 {
5190 /*
5191 * All supported sampling methods require sampling rate, not
5192 * target rows directly, so we calculate that using the remote
5193 * reltuples value. That's imperfect, because it might be off a
5194 * good deal, but that's not something we can (or should) address
5195 * here.
5196 *
5197 * If reltuples is too low (i.e. when table grew), we'll end up
5198 * sampling more rows - but then we'll apply the local sampling,
5199 * so we get the expected sample size. This is the same outcome as
5200 * without remote sampling.
5201 *
5202 * If reltuples is too high (e.g. after bulk DELETE), we will end
5203 * up sampling too few rows.
5204 *
5205 * We can't really do much better here - we could try sampling a
5206 * bit more rows, but we don't know how off the reltuples value is
5207 * so how much is "a bit more"?
5208 *
5209 * Furthermore, the targrows value for partitions is determined
5210 * based on table size (relpages), which can be off in different
5211 * ways too. Adjusting the sampling rate here might make the issue
5212 * worse.
5213 */
5216 /*
5217 * We should never get sampling rate outside the valid range
5218 * (between 0.0 and 1.0), because those cases should be covered by
5219 * the previous branch that sets ANALYZE_SAMPLE_OFF.
5220 */
5222 }
5223 }
5225 /*
5226 * For "auto" method, pick the one we believe is best. For servers with
5227 * TABLESAMPLE support we pick BERNOULLI, for old servers we fall-back to
5228 * random() to at least reduce network transfer.
5229 */
5231 {
5234 else
5236 }
5238 /*
5239 * Construct cursor that retrieves whole rows from remote.
5240 */
5247 /* In what follows, do not risk leaking any PGresults. */
5249 {
5259 /*
5260 * Determine the fetch size. The default is arbitrary, but shouldn't
5261 * be enormous.
5262 */
5265 {
5269 {
5272 }
5273 }
5275 {
5279 {
5282 }
5283 }
5285 /* Construct command to fetch rows from remote. */
5289 /* Retrieve and process rows a batch at a time. */
5291 {
5295 /* Allow users to cancel long query */
5298 /*
5299 * XXX possible future improvement: if rowstoskip is large, we
5300 * could issue a MOVE rather than physically fetching the rows,
5301 * then just adjust rowstoskip and samplerows appropriately.
5302 */
5304 /* Fetch some rows */
5306 /* On error, report the original query, not the FETCH. */
5310 /* Process whatever we got. */
5318 /* Must be EOF if we didn't get all the rows requested. */
5321 }
5323 /* Close the cursor, just to be tidy. */
5325 }
5327 {
5330 }
5335 /* We assume that we have no dead tuple. */
5338 /*
5339 * Without sampling, we've retrieved all living tuples from foreign
5340 * server, so report that as totalrows. Otherwise use the reltuples
5341 * estimate we got from the remote side.
5342 */
5345 else
5348 /*
5349 * Emit some interesting relation info
5350 */
5357 }
5359 /*
5360 * Collect sample rows from the result of query.
5361 * - Use all tuples in sample until target # of samples are collected.
5362 * - Subsequently, replace already-sampled tuples randomly.
5363 */
5364 static void
5366 {
5369 MemoryContext oldcontext;
5371 /* Always increment sample row counter. */
5374 /*
5375 * Determine the slot where this sample row should be stored. Set pos to
5376 * negative value to indicate the row should be skipped.
5377 */
5379 {
5380 /* First targrows rows are always included into the sample */
5382 }
5383 else
5384 {
5385 /*
5386 * Now we start replacing tuples in the sample until we reach the end
5387 * of the relation. Same algorithm as in acquire_sample_rows in
5388 * analyze.c; see Jeff Vitter's paper.
5389 */
5394 {
5395 /* Choose a random reservoir element to replace. */
5399 }
5400 else
5401 {
5402 /* Skip this tuple. */
5404 }
5407 }
5410 {
5411 /*
5412 * Create sample tuple from current result row, and store it in the
5413 * position determined above. The tuple has to be created in anl_cxt.
5414 */
5421 NULL,
5425 }
5426 }
5428 /*
5429 * Import a foreign schema
5430 */
5433 {
5442 StringInfoData buf;
5445 i;
5448 /* Parse statement options */
5450 {
5461 else
5465 }
5467 /*
5468 * Get connection to the foreign server. Connection manager will
5469 * establish new connection if necessary.
5470 */
5475 /* Don't attempt to import collation if remote server hasn't got it */
5479 /* Create workspace for strings */
5482 /* In what follows, do not risk leaking any PGresults. */
5484 {
5485 /* Check that the schema really exists */
5503 /*
5504 * Fetch all table data from this schema, possibly restricted by
5505 * EXCEPT or LIMIT TO. (We don't actually need to pay any attention
5506 * to EXCEPT/LIMIT TO here, because the core code will filter the
5507 * statements we return according to those lists anyway. But it
5508 * should save a few cycles to not process excluded tables in the
5509 * first place.)
5510 *
5511 * Import table data for partitions only when they are explicitly
5512 * specified in LIMIT TO clause. Otherwise ignore them and only
5513 * include the definitions of the root partitioned tables to allow
5514 * access to the complete remote data set locally in the schema
5515 * imported.
5516 *
5517 * Note: because we run the connection with search_path restricted to
5518 * pg_catalog, the format_type() and pg_get_expr() outputs will always
5519 * include a schema name for types/functions in other schemas, which
5520 * is what we want.
5521 */
5523 "SELECT relname, "
5524 " attname, "
5525 " format_type(atttypid, atttypmod), "
5526 " attnotnull, "
5529 /* Generated columns are supported since Postgres 12 */
5533 else
5539 " collname, "
5541 else
5546 "FROM pg_class c "
5547 " JOIN pg_namespace n ON "
5548 " relnamespace = n.oid "
5549 " LEFT JOIN pg_attribute a ON "
5550 " attrelid = c.oid AND attnum > 0 "
5551 " AND NOT attisdropped "
5552 " LEFT JOIN pg_attrdef ad ON "
5557 " LEFT JOIN pg_collation coll ON "
5558 " coll.oid = attcollation "
5559 " LEFT JOIN pg_namespace collnsp ON "
5563 "WHERE c.relkind IN ("
5572 /* Partitions are supported since Postgres 10 */
5577 /* Apply restrictions for LIMIT TO and EXCEPT */
5580 {
5588 /* Append list of table names within IN clause */
5590 {
5595 else
5598 }
5600 }
5602 /* Append ORDER BY at the end of query to ensure output ordering */
5605 /* Fetch the data */
5610 /* Process results */
5612 /* note: incrementation of i happens in inner loop's while() test */
5614 {
5622 /* Scan all rows for this table */
5623 do
5624 {
5633 /* If table has no columns, we'll see nulls here */
5651 else
5654 /* Print column name and type */
5657 typename);
5659 /*
5660 * Add column_name option so that renaming the foreign table's
5661 * column doesn't break the association to the underlying
5662 * column.
5663 */
5668 /* Add COLLATE if needed */
5674 /* Add DEFAULT if needed */
5679 /* Add GENERATED if needed */
5682 {
5686 attdefault);
5687 }
5689 /* Add NOT NULL if needed */
5692 }
5696 /*
5697 * Add server name and table-level options. We specify remote
5698 * schema and table name as options (the latter to ensure that
5699 * renaming the foreign table doesn't break the association).
5700 */
5712 }
5713 }
5715 {
5717 }
5723 }
5725 /*
5726 * Assess whether the join between inner and outer relations can be pushed down
5727 * to the foreign server. As a side effect, save information we obtain in this
5728 * function to PgFdwRelationInfo passed in.
5729 */
5730 static bool
5734 {
5741 /*
5742 * We support pushing down INNER, LEFT, RIGHT and FULL OUTER joins.
5743 * Constructing queries representing SEMI and ANTI joins is hard, hence
5744 * not considered right now.
5745 */
5750 /*
5751 * If either of the joining relations is marked as unsafe to pushdown, the
5752 * join can not be pushed down.
5753 */
5761 /*
5762 * If joining relations have local conditions, those conditions are
5763 * required to be applied before joining the relations. Hence the join can
5764 * not be pushed down.
5765 */
5769 /*
5770 * Merge FDW options. We might be tempted to do this after we have deemed
5771 * the foreign join to be OK. But we must do this beforehand so that we
5772 * know which quals can be evaluated on the foreign server, which might
5773 * depend on shippable_extensions.
5774 */
5778 /*
5779 * Separate restrict list into join quals and pushed-down (other) quals.
5780 *
5781 * Join quals belonging to an outer join must all be shippable, else we
5782 * cannot execute the join remotely. Add such quals to 'joinclauses'.
5783 *
5784 * Add other quals to fpinfo->remote_conds if they are shippable, else to
5785 * fpinfo->local_conds. In an inner join it's okay to execute conditions
5786 * either locally or remotely; the same is true for pushed-down conditions
5787 * at an outer join.
5788 *
5789 * Note we might return failure after having already scribbled on
5790 * fpinfo->remote_conds and fpinfo->local_conds. That's okay because we
5791 * won't consult those lists again if we deem the join unshippable.
5792 */
5795 {
5802 {
5806 }
5807 else
5808 {
5811 else
5813 }
5814 }
5816 /*
5817 * deparseExplicitTargetList() isn't smart enough to handle anything other
5818 * than a Var. In particular, if there's some PlaceHolderVar that would
5819 * need to be evaluated within this join tree (because there's an upper
5820 * reference to a quantity that may go to NULL as a result of an outer
5821 * join), then we can't try to push the join down because we'll fail when
5822 * we get to deparseExplicitTargetList(). However, a PlaceHolderVar that
5823 * needs to be evaluated *at the top* of this join tree is OK, because we
5824 * can do that locally after fetching the results from the remote side.
5825 */
5827 {
5829 Relids relids;
5831 /* PlaceHolderInfo refers to parent relids, not child relids. */
5838 }
5840 /* Save the join clauses, for later use. */
5847 /*
5848 * By default, both the input relations are not required to be deparsed as
5849 * subqueries, but there might be some relations covered by the input
5850 * relations that are required to be deparsed as subqueries, so save the
5851 * relids of those relations for later use by the deparser.
5852 */
5860 /*
5861 * Pull the other remote conditions from the joining relations into join
5862 * clauses or other remote clauses (remote_conds) of this relation
5863 * wherever possible. This avoids building subqueries at every join step.
5864 *
5865 * For an inner join, clauses from both the relations are added to the
5866 * other remote clauses. For LEFT and RIGHT OUTER join, the clauses from
5867 * the outer side are added to remote_conds since those can be evaluated
5868 * after the join is evaluated. The clauses from inner side are added to
5869 * the joinclauses, since they need to be evaluated while constructing the
5870 * join.
5871 *
5872 * For a FULL OUTER JOIN, the other clauses from either relation can not
5873 * be added to the joinclauses or remote_conds, since each relation acts
5874 * as an outer relation for the other.
5875 *
5876 * The joining sides can not have local conditions, thus no need to test
5877 * shippability of the clauses being pulled up.
5878 */
5880 {
5904 /*
5905 * In this case, if any of the input relations has conditions, we
5906 * need to deparse that relation as a subquery so that the
5907 * conditions can be evaluated before the join. Remember it in
5908 * the fpinfo of this relation so that the deparser can take
5909 * appropriate action. Also, save the relids of base relations
5910 * covered by that relation for later use by the deparser.
5911 */
5913 {
5918 }
5920 {
5925 }
5929 /* Should not happen, we have just checked this above */
5931 }
5933 /*
5934 * For an inner join, all restrictions can be treated alike. Treating the
5935 * pushed down conditions as join conditions allows a top level full outer
5936 * join to be deparsed without requiring subqueries.
5937 */
5939 {
5943 }
5945 /* Mark that this join can be pushed down safely */
5948 /* Get user mapping */
5950 {
5953 else
5955 }
5956 else
5959 /*
5960 * Set # of retrieved rows and cached relation costs to some negative
5961 * value, so that we can detect when they are set to some sensible values,
5962 * during one (usually the first) of the calls to estimate_path_cost_size.
5963 */
5968 /*
5969 * Set the string describing this join relation to be used in EXPLAIN
5970 * output of corresponding ForeignScan. Note that the decoration we add
5971 * to the base relation names mustn't include any digits, or it'll confuse
5972 * postgresExplainForeignScan.
5973 */
5979 /*
5980 * Set the relation index. This is defined as the position of this
5981 * joinrel in the join_rel_list list plus the length of the rtable list.
5982 * Note that since this joinrel is at the end of the join_rel_list list
5983 * when we are called, we can get the position by list_length.
5984 */
5990 }
5992 static void
5995 {
6001 /*
6002 * Before creating sorted paths, arrange for the passed-in EPQ path, if
6003 * any, to return columns needed by the parent ForeignScan node so that
6004 * they will propagate up through Sort nodes injected below, if necessary.
6005 */
6007 {
6011 /* Include columns required for evaluating PHVs in the tlist. */
6014 PVC_RECURSE_PLACEHOLDERS));
6016 /* Include columns required for evaluating the local conditions. */
6018 {
6023 PVC_RECURSE_PLACEHOLDERS));
6024 }
6026 /*
6027 * If we have added any new columns, adjust the tlist of the EPQ path.
6028 *
6029 * Note: the plan created using this path will only be used to execute
6030 * EPQ checks, where accuracy of the plan cost and width estimates
6031 * would not be important, so we do not do set_pathtarget_cost_width()
6032 * for the new pathtarget here. See also postgresGetForeignPlan().
6033 */
6035 {
6036 /* The EPQ path is a join path, so it is projection-capable. */
6039 /*
6040 * Use create_projection_path() here, so as to avoid modifying it
6041 * in place.
6042 */
6044 rel,
6045 epq_path,
6046 target);
6047 }
6048 }
6050 /* Create one path for each set of pathkeys we found above. */
6052 {
6055 Cost startup_cost;
6056 Cost total_cost;
6063 /*
6064 * The EPQ path must be at least as well sorted as the path itself, in
6065 * case it gets used as input to a mergejoin.
6066 */
6073 rel,
6074 sorted_epq_path,
6075 useful_pathkeys,
6081 NULL,
6082 rows,
6083 startup_cost,
6084 total_cost,
6085 useful_pathkeys,
6087 sorted_epq_path,
6088 NIL));
6089 else
6092 NULL,
6093 rows,
6094 startup_cost,
6095 total_cost,
6096 useful_pathkeys,
6098 sorted_epq_path,
6099 NIL));
6100 }
6101 }
6103 /*
6104 * Parse options from foreign server and apply them to fpinfo.
6105 *
6106 * New options might also require tweaking merge_fdw_options().
6107 */
6108 static void
6110 {
6114 {
6121 NULL);
6124 NULL);
6132 }
6133 }
6135 /*
6136 * Parse options from foreign table and apply them to fpinfo.
6137 *
6138 * New options might also require tweaking merge_fdw_options().
6139 */
6140 static void
6142 {
6146 {
6155 }
6156 }
6158 /*
6159 * Merge FDW options from input relations into a new set of options for a join
6160 * or an upper rel.
6161 *
6162 * For a join relation, FDW-specific information about the inner and outer
6163 * relations is provided using fpinfo_i and fpinfo_o. For an upper relation,
6164 * fpinfo_o provides the information for the input relation; fpinfo_i is
6165 * expected to NULL.
6166 */
6167 static void
6171 {
6172 /* We must always have fpinfo_o. */
6175 /* fpinfo_i may be NULL, but if present the servers must both match. */
6179 /*
6180 * Copy the server specific FDW options. (For a join, both relations come
6181 * from the same server, so the server options should have the same value
6182 * for both relations.)
6183 */
6191 /* Merge the table level options from either side of the join. */
6193 {
6194 /*
6195 * We'll prefer to use remote estimates for this join if any table
6196 * from either side of the join is using remote estimates. This is
6197 * most likely going to be preferred since they're already willing to
6198 * pay the price of a round trip to get the remote EXPLAIN. In any
6199 * case it's not entirely clear how we might otherwise handle this
6200 * best.
6201 */
6205 /*
6206 * Set fetch size to maximum of the joining sides, since we are
6207 * expecting the rows returned by the join to be proportional to the
6208 * relation sizes.
6209 */
6212 /*
6213 * We'll prefer to consider this join async-capable if any table from
6214 * either side of the join is considered async-capable. This would be
6215 * reasonable because in that case the foreign server would have its
6216 * own resources to scan that table asynchronously, and the join could
6217 * also be computed asynchronously using the resources.
6218 */
6221 }
6222 }
6224 /*
6225 * postgresGetForeignJoinPaths
6226 * Add possible ForeignPath to joinrel, if join is safe to push down.
6227 */
6228 static void
6233 JoinType jointype,
6235 {
6240 Cost startup_cost;
6241 Cost total_cost;
6243 * EvalPlanQual gets triggered. */
6245 /*
6246 * Skip if this join combination has been considered already.
6247 */
6251 /*
6252 * This code does not work for joins with lateral references, since those
6253 * must have parameterized paths, which we don't generate yet.
6254 */
6258 /*
6259 * Create unfinished PgFdwRelationInfo entry which is used to indicate
6260 * that the join relation is already considered, so that we won't waste
6261 * time in judging safety of join pushdown and adding the same paths again
6262 * if found safe. Once we know that this join can be pushed down, we fill
6263 * the entry.
6264 */
6268 /* attrs_used is only for base relations. */
6271 /*
6272 * If there is a possibility that EvalPlanQual will be executed, we need
6273 * to be able to reconstruct the row using scans of the base relations.
6274 * GetExistingLocalJoinPath will find a suitable path for this purpose in
6275 * the path list of the joinrel, if one exists. We must be careful to
6276 * call it before adding any ForeignPath, since the ForeignPath might
6277 * dominate the only suitable local path available. We also do it before
6278 * calling foreign_join_ok(), since that function updates fpinfo and marks
6279 * it as pushable if the join is found to be pushable.
6280 */
6284 {
6287 {
6288 elog(DEBUG3, "could not push down foreign join because a local path suitable for EPQ checks was not found");
6290 }
6291 }
6292 else
6296 {
6297 /* Free path required for EPQ if we copied one; we don't need it now */
6301 }
6303 /*
6304 * Compute the selectivity and cost of the local_conds, so we don't have
6305 * to do it over again for each path. The best we can do for these
6306 * conditions is to estimate selectivity on the basis of local statistics.
6307 * The local conditions are applied after the join has been computed on
6308 * the remote side like quals in WHERE clause, so pass jointype as
6309 * JOIN_INNER.
6310 */
6314 JOIN_INNER,
6315 NULL);
6318 /*
6319 * If we are going to estimate costs locally, estimate the join clause
6320 * selectivity here while we have special join info.
6321 */
6327 /* Estimate costs for bare join relation */
6330 /* Now update this information in the joinrel */
6338 /*
6339 * Create a new join path and add it to the joinrel which represents a
6340 * join between foreign tables.
6341 */
6343 joinrel,
6345 rows,
6346 startup_cost,
6347 total_cost,
6350 epq_path,
6353 /* Add generated path into joinrel by add_path(). */
6356 /* Consider pathkeys for the join relation */
6359 /* XXX Consider parameterized paths for the join relation */
6360 }
6362 /*
6363 * Assess whether the aggregation, grouping and having operations can be pushed
6364 * down to the foreign server. As a side effect, save information we obtain in
6365 * this function to PgFdwRelationInfo of the input relation.
6366 */
6367 static bool
6370 {
6379 /* We currently don't support pushing Grouping Sets. */
6383 /* Get the fpinfo of the underlying scan relation. */
6386 /*
6387 * If underlying scan relation has any local conditions, those conditions
6388 * are required to be applied before performing aggregation. Hence the
6389 * aggregate cannot be pushed down.
6390 */
6394 /*
6395 * Examine grouping expressions, as well as other expressions we'd need to
6396 * compute, and check whether they are safe to push down to the foreign
6397 * server. All GROUP BY expressions will be part of the grouping target
6398 * and thus there is no need to search for them separately. Add grouping
6399 * expressions into target list which will be passed to foreign server.
6400 *
6401 * A tricky fine point is that we must not put any expression into the
6402 * target list that is just a foreign param (that is, something that
6403 * deparse.c would conclude has to be sent to the foreign server). If we
6404 * do, the expression will also appear in the fdw_exprs list of the plan
6405 * node, and setrefs.c will get confused and decide that the fdw_exprs
6406 * entry is actually a reference to the fdw_scan_tlist entry, resulting in
6407 * a broken plan. Somewhat oddly, it's OK if the expression contains such
6408 * a node, as long as it's not at top level; then no match is possible.
6409 */
6412 {
6417 /*
6418 * Check whether this expression is part of GROUP BY clause. Note we
6419 * check the whole GROUP BY clause not just processed_groupClause,
6420 * because we will ship all of it, cf. appendGroupByClause.
6421 */
6423 {
6426 /*
6427 * If any GROUP BY expression is not shippable, then we cannot
6428 * push down aggregation to the foreign server.
6429 */
6433 /*
6434 * If it would be a foreign param, we can't put it into the tlist,
6435 * so we have to fail.
6436 */
6440 /*
6441 * Pushable, so add to tlist. We need to create a TLE for this
6442 * expression and apply the sortgroupref to it. We cannot use
6443 * add_to_flat_tlist() here because that avoids making duplicate
6444 * entries in the tlist. If there are duplicate entries with
6445 * distinct sortgrouprefs, we have to duplicate that situation in
6446 * the output tlist.
6447 */
6451 }
6452 else
6453 {
6454 /*
6455 * Non-grouping expression we need to compute. Can we ship it
6456 * as-is to the foreign server?
6457 */
6460 {
6461 /* Yes, so add to tlist as-is; OK to suppress duplicates */
6463 }
6464 else
6465 {
6466 /* Not pushable as a whole; extract its Vars and aggregates */
6470 PVC_INCLUDE_AGGREGATES);
6472 /*
6473 * If any aggregate expression is not shippable, then we
6474 * cannot push down aggregation to the foreign server. (We
6475 * don't have to check is_foreign_param, since that certainly
6476 * won't return true for any such expression.)
6477 */
6481 /*
6482 * Add aggregates, if any, into the targetlist. Plain Vars
6483 * outside an aggregate can be ignored, because they should be
6484 * either same as some GROUP BY column or part of some GROUP
6485 * BY expression. In either case, they are already part of
6486 * the targetlist and thus no need to add them again. In fact
6487 * including plain Vars in the tlist when they do not match a
6488 * GROUP BY column would cause the foreign server to complain
6489 * that the shipped query is invalid.
6490 */
6492 {
6497 }
6498 }
6499 }
6501 i++;
6502 }
6504 /*
6505 * Classify the pushable and non-pushable HAVING clauses and save them in
6506 * remote_conds and local_conds of the grouped rel's fpinfo.
6507 */
6509 {
6511 {
6515 /*
6516 * Currently, the core code doesn't wrap havingQuals in
6517 * RestrictInfos, so we must make our own.
6518 */
6521 expr,
6528 NULL,
6529 NULL);
6532 else
6534 }
6535 }
6537 /*
6538 * If there are any local conditions, pull Vars and aggregates from it and
6539 * check whether they are safe to pushdown or not.
6540 */
6542 {
6546 {
6551 PVC_INCLUDE_AGGREGATES));
6552 }
6555 {
6558 /*
6559 * If aggregates within local conditions are not safe to push
6560 * down, then we cannot push down the query. Vars are already
6561 * part of GROUP BY clause which are checked above, so no need to
6562 * access them again here. Again, we need not check
6563 * is_foreign_param for a foreign aggregate.
6564 */
6566 {
6571 }
6572 }
6573 }
6575 /* Store generated targetlist */
6578 /* Safe to pushdown */
6581 /*
6582 * Set # of retrieved rows and cached relation costs to some negative
6583 * value, so that we can detect when they are set to some sensible values,
6584 * during one (usually the first) of the calls to estimate_path_cost_size.
6585 */
6590 /*
6591 * Set the string describing this grouped relation to be used in EXPLAIN
6592 * output of corresponding ForeignScan. Note that the decoration we add
6593 * to the base relation name mustn't include any digits, or it'll confuse
6594 * postgresExplainForeignScan.
6595 */
6600 }
6602 /*
6603 * postgresGetForeignUpperPaths
6604 * Add paths for post-join operations like aggregation, grouping etc. if
6605 * corresponding operations are safe to push down.
6606 */
6607 static void
6611 {
6614 /*
6615 * If input rel is not safe to pushdown, then simply return as we cannot
6616 * perform any post-join operations on the foreign server.
6617 */
6622 /* Ignore stages we don't support; and skip any duplicate calls. */
6635 {
6650 }
6651 }
6653 /*
6654 * add_foreign_grouping_paths
6655 * Add foreign path for grouping and/or aggregation.
6656 *
6657 * Given input_rel represents the underlying scan. The paths are added to the
6658 * given grouped_rel.
6659 */
6660 static void
6664 {
6671 Cost startup_cost;
6672 Cost total_cost;
6674 /* Nothing to be done, if there is no grouping or aggregation required. */
6682 /* save the input_rel as outerrel in fpinfo */
6685 /*
6686 * Copy foreign table, foreign server, user mapping, FDW options etc.
6687 * details from the input relation's fpinfo.
6688 */
6694 /*
6695 * Assess if it is safe to push down aggregation and grouping.
6696 *
6697 * Use HAVING qual from extra. In case of child partition, it will have
6698 * translated Vars.
6699 */
6703 /*
6704 * Compute the selectivity and cost of the local_conds, so we don't have
6705 * to do it over again for each path. (Currently we create just a single
6706 * path here, but in future it would be possible that we build more paths
6707 * such as pre-sorted paths as in postgresGetForeignPaths and
6708 * postgresGetForeignJoinPaths.) The best we can do for these conditions
6709 * is to estimate selectivity on the basis of local statistics.
6710 */
6714 JOIN_INNER,
6715 NULL);
6719 /* Estimate the cost of push down */
6723 /* Now update this information in the fpinfo */
6729 /* Create and add foreign path to the grouping relation. */
6731 grouped_rel,
6733 rows,
6734 startup_cost,
6735 total_cost,
6737 NULL,
6740 /* Add generated path into grouped_rel by add_path(). */
6742 }
6744 /*
6745 * add_foreign_ordered_paths
6746 * Add foreign paths for performing the final sort remotely.
6747 *
6748 * Given input_rel contains the source-data Paths. The paths are added to the
6749 * given ordered_rel.
6750 */
6751 static void
6754 {
6761 Cost startup_cost;
6762 Cost total_cost;
6767 /* Shouldn't get here unless the query has ORDER BY */
6770 /* We don't support cases where there are any SRFs in the targetlist */
6774 /* Save the input_rel as outerrel in fpinfo */
6777 /*
6778 * Copy foreign table, foreign server, user mapping, FDW options etc.
6779 * details from the input relation's fpinfo.
6780 */
6786 /*
6787 * If the input_rel is a base or join relation, we would already have
6788 * considered pushing down the final sort to the remote server when
6789 * creating pre-sorted foreign paths for that relation, because the
6790 * query_pathkeys is set to the root->sort_pathkeys in that case (see
6791 * standard_qp_callback()).
6792 */
6795 {
6798 /* Safe to push down if the query_pathkeys is safe to push down */
6802 }
6804 /* The input_rel should be a grouping relation */
6808 /*
6809 * We try to create a path below by extending a simple foreign path for
6810 * the underlying grouping relation to perform the final sort remotely,
6811 * which is stored into the fdw_private list of the resulting path.
6812 */
6814 /* Assess if it is safe to push down the final sort */
6816 {
6820 /*
6821 * is_foreign_expr would detect volatile expressions as well, but
6822 * checking ec_has_volatile here saves some cycles.
6823 */
6827 /*
6828 * Can't push down the sort if pathkey's opfamily is not shippable.
6829 */
6831 fpinfo))
6834 /*
6835 * The EC must contain a shippable EM that is computed in input_rel's
6836 * reltarget, else we can't push down the sort.
6837 */
6839 pathkey_ec,
6842 }
6844 /* Safe to push down */
6847 /* Construct PgFdwPathExtraData */
6852 /* Estimate the costs of performing the final sort remotely */
6856 /*
6857 * Build the fdw_private list that will be used by postgresGetForeignPlan.
6858 * Items in the list must match order in enum FdwPathPrivateIndex.
6859 */
6862 /* Create foreign ordering path */
6864 input_rel,
6866 rows,
6867 startup_cost,
6868 total_cost,
6871 fdw_private);
6873 /* and add it to the ordered_rel */
6875 }
6877 /*
6878 * add_foreign_final_paths
6879 * Add foreign paths for performing the final processing remotely.
6880 *
6881 * Given input_rel contains the source-data Paths. The paths are added to the
6882 * given final_rel.
6883 */
6884 static void
6888 {
6898 Cost startup_cost;
6899 Cost total_cost;
6903 /*
6904 * Currently, we only support this for SELECT commands
6905 */
6909 /*
6910 * No work if there is no FOR UPDATE/SHARE clause and if there is no need
6911 * to add a LIMIT node
6912 */
6916 /* We don't support cases where there are any SRFs in the targetlist */
6920 /* Save the input_rel as outerrel in fpinfo */
6923 /*
6924 * Copy foreign table, foreign server, user mapping, FDW options etc.
6925 * details from the input relation's fpinfo.
6926 */
6932 /*
6933 * If there is no need to add a LIMIT node, there might be a ForeignPath
6934 * in the input_rel's pathlist that implements all behavior of the query.
6935 * Note: we would already have accounted for the query's FOR UPDATE/SHARE
6936 * (if any) before we get here.
6937 */
6939 {
6944 /*
6945 * Grouping and aggregation are not supported with FOR UPDATE/SHARE,
6946 * so the input_rel should be a base, join, or ordered relation; and
6947 * if it's an ordered relation, its input relation should be a base or
6948 * join relation.
6949 */
6958 {
6961 /*
6962 * apply_scanjoin_target_to_paths() uses create_projection_path()
6963 * to adjust each of its input paths if needed, whereas
6964 * create_ordered_paths() uses apply_projection_to_path() to do
6965 * that. So the former might have put a ProjectionPath on top of
6966 * the ForeignPath; look through ProjectionPath and see if the
6967 * path underneath it is ForeignPath.
6968 */
6972 {
6973 /*
6974 * Create foreign final path; this gets rid of a
6975 * no-longer-needed outer plan (if any), which makes the
6976 * EXPLAIN output look cleaner
6977 */
6988 /* and add it to the final_rel */
6991 /* Safe to push down */
6995 }
6996 }
6998 /*
6999 * If we get here it means no ForeignPaths; since we would already
7000 * have considered pushing down all operations for the query to the
7001 * remote server, give up on it.
7002 */
7004 }
7008 /*
7009 * If the input_rel is an ordered relation, replace the input_rel with its
7010 * input relation
7011 */
7014 {
7019 }
7021 /* The input_rel should be a base, join, or grouping relation */
7027 /*
7028 * We try to create a path below by extending a simple foreign path for
7029 * the underlying base, join, or grouping relation to perform the final
7030 * sort (if has_final_sort) and the LIMIT restriction remotely, which is
7031 * stored into the fdw_private list of the resulting path. (We
7032 * re-estimate the costs of sorting the underlying relation, if
7033 * has_final_sort.)
7034 */
7036 /*
7037 * Assess if it is safe to push down the LIMIT and OFFSET to the remote
7038 * server
7039 */
7041 /*
7042 * If the underlying relation has any local conditions, the LIMIT/OFFSET
7043 * cannot be pushed down.
7044 */
7048 /*
7049 * Also, the LIMIT/OFFSET cannot be pushed down, if their expressions are
7050 * not safe to remote.
7051 */
7056 /* Safe to push down */
7059 /* Construct PgFdwPathExtraData */
7068 /*
7069 * Estimate the costs of performing the final sort and the LIMIT
7070 * restriction remotely. If has_final_sort is false, we wouldn't need to
7071 * execute EXPLAIN anymore if use_remote_estimate, since the costs can be
7072 * roughly estimated using the costs we already have for the underlying
7073 * relation, in the same way as when use_remote_estimate is false. Since
7074 * it's pretty expensive to execute EXPLAIN, force use_remote_estimate to
7075 * false in that case.
7076 */
7078 {
7081 }
7087 /*
7088 * Build the fdw_private list that will be used by postgresGetForeignPlan.
7089 * Items in the list must match order in enum FdwPathPrivateIndex.
7090 */
7094 /*
7095 * Create foreign final path; this gets rid of a no-longer-needed outer
7096 * plan (if any), which makes the EXPLAIN output look cleaner
7097 */
7099 input_rel,
7101 rows,
7102 startup_cost,
7103 total_cost,
7104 pathkeys,
7106 fdw_private);
7108 /* and add it to the final_rel */
7110 }
7112 /*
7113 * postgresIsForeignPathAsyncCapable
7114 * Check whether a given ForeignPath node is async-capable.
7115 */
7116 static bool
7118 {
7123 }
7125 /*
7126 * postgresForeignAsyncRequest
7127 * Asynchronously request next tuple from a foreign PostgreSQL table.
7128 */
7129 static void
7131 {
7133 }
7135 /*
7136 * postgresForeignAsyncConfigureWait
7137 * Configure a file descriptor event for which we wish to wait.
7138 */
7139 static void
7141 {
7148 /* This should not be called unless callback_pending */
7151 /*
7152 * If process_pending_request() has been invoked on the given request
7153 * before we get here, we might have some tuples already; in which case
7154 * complete the request
7155 */
7157 {
7162 }
7164 /* We must have run out of tuples */
7167 /* The core code would have registered postmaster death event */
7170 /* Begin an asynchronous data fetch if not already done */
7174 {
7175 /*
7176 * This is the case when the in-process request was made by another
7177 * Append. Note that it might be useless to process the request,
7178 * because the query might not need tuples from that Append anymore.
7179 * If there are any child subplans of the same parent that are ready
7180 * for new requests, skip the given request. Likewise, if there are
7181 * any configured events other than the postmaster death event, skip
7182 * it. Otherwise, process the in-process request, then begin a fetch
7183 * to configure the event below, because we might otherwise end up
7184 * with no configured events other than the postmaster death event.
7185 */
7192 }
7194 {
7195 /*
7196 * This is the case when the in-process request was made by the same
7197 * parent but for a different child. Since we configure only the
7198 * event for the request made for that child, skip the given request.
7199 */
7201 }
7202 else
7207 }
7209 /*
7210 * postgresForeignAsyncNotify
7211 * Fetch some more tuples from a file descriptor that becomes ready,
7212 * requesting next tuple.
7213 */
7214 static void
7216 {
7220 /* The core code would have initialized the callback_pending flag */
7223 /*
7224 * If process_pending_request() has been invoked on the given request
7225 * before we get here, we might have some tuples already; in which case
7226 * produce the next tuple
7227 */
7229 {
7232 }
7234 /* We must have run out of tuples */
7237 /* The request should be currently in-process */
7240 /* On error, report the original query, not the FETCH. */
7247 }
7249 /*
7250 * Asynchronously produce next tuple from a foreign PostgreSQL table.
7251 */
7252 static void
7254 {
7260 /* This should not be called if the request is currently in-process */
7263 /* Fetch some more tuples, if we've run out */
7265 {
7266 /* No point in another fetch if we already detected EOF, though */
7268 {
7269 /* Mark the request as pending for a callback */
7271 /* Begin another fetch if requested and if no pending request */
7274 }
7275 else
7276 {
7277 /* There's nothing more to do; just return a NULL pointer */
7279 /* Mark the request as complete */
7281 }
7283 }
7285 /* Get a tuple from the ForeignScan node */
7288 {
7289 /* Mark the request as complete */
7292 }
7294 /* We must have run out of tuples */
7297 /* Fetch some more tuples, if we've not detected EOF yet */
7299 {
7300 /* Mark the request as pending for a callback */
7302 /* Begin another fetch if requested and if no pending request */
7305 }
7306 else
7307 {
7308 /* There's nothing more to do; just return a NULL pointer */
7310 /* Mark the request as complete */
7312 }
7313 }
7315 /*
7316 * Begin an asynchronous data fetch.
7317 *
7318 * Note: this function assumes there is no currently-in-progress asynchronous
7319 * data fetch.
7320 *
7321 * Note: fetch_more_data must be called to fetch the result.
7322 */
7323 static void
7325 {
7332 /* Create the cursor synchronously. */
7336 /* We will send this query, but not wait for the response. */
7343 /* Remember that the request is in process */
7345 }
7347 /*
7348 * Process a pending asynchronous request.
7349 */
7350 void
7352 {
7356 /* The request would have been pending for a callback */
7359 /* The request should be currently in-process */
7364 /*
7365 * If we didn't get any tuples, must be end of data; complete the request
7366 * now. Otherwise, we postpone completing the request until we are called
7367 * from postgresForeignAsyncConfigureWait()/postgresForeignAsyncNotify().
7368 */
7370 {
7371 /* Unlike AsyncNotify, we unset callback_pending ourselves */
7373 /* Mark the request as complete */
7375 /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
7377 }
7378 }
7380 /*
7381 * Complete a pending asynchronous request.
7382 */
7383 static void
7385 {
7386 /* The request would have been pending for a callback */
7389 /* Unlike AsyncNotify, we unset callback_pending ourselves */
7392 /* We begin a fetch afterwards if necessary; don't fetch */
7395 /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
7398 /* Also, we do instrumentation ourselves, if required */
7402 }
7404 /*
7405 * Create a tuple from the specified row of the PGresult.
7406 *
7407 * rel is the local representation of the foreign table, attinmeta is
7408 * conversion data for the rel's tupdesc, and retrieved_attrs is an
7409 * integer list of the table column numbers present in the PGresult.
7410 * fsstate is the ForeignScan plan node's execution state.
7411 * temp_context is a working context that can be reset after each tuple.
7412 *
7413 * Note: either rel or fsstate, but not both, can be NULL. rel is NULL
7414 * if we're processing a remote join, while fsstate is NULL in a non-query
7415 * context such as ANALYZE, or if we're processing a non-scan query node.
7416 */
7417 static HeapTuple
7420 Relation rel,
7424 MemoryContext temp_context)
7425 {
7426 HeapTuple tuple;
7427 TupleDesc tupdesc;
7431 ConversionLocation errpos;
7432 ErrorContextCallback errcallback;
7433 MemoryContext oldcontext;
7439 /*
7440 * Do the following work in a temp context that we reset after each tuple.
7441 * This cleans up not only the data we have direct access to, but any
7442 * cruft the I/O functions might leak.
7443 */
7446 /*
7447 * Get the tuple descriptor for the row. Use the rel's tupdesc if rel is
7448 * provided, otherwise look to the scan node's ScanTupleSlot.
7449 */
7452 else
7453 {
7456 }
7460 /* Initialize to nulls for any columns not present in result */
7463 /*
7464 * Set up and install callback to report where conversion error occurs.
7465 */
7474 /*
7475 * i indexes columns in the relation, j indexes columns in the PGresult.
7476 */
7479 {
7483 /* fetch next column's textual value */
7486 else
7489 /*
7490 * convert value to internal representation
7491 *
7492 * Note: we ignore system columns other than ctid and oid in result
7493 */
7496 {
7497 /* ordinary column */
7500 /* Apply the input function even to nulls, to support domains */
7502 valstr,
7505 }
7507 {
7508 /* ctid */
7510 {
7511 Datum datum;
7515 }
7516 }
7519 j++;
7520 }
7522 /* Uninstall error context callback. */
7525 /*
7526 * Check we got the expected number of columns. Note: j == 0 and
7527 * PQnfields == 1 is expected, since deparse emits a NULL if no columns.
7528 */
7532 /*
7533 * Build the result tuple in caller's memory context.
7534 */
7539 /*
7540 * If we have a CTID to return, install it in both t_self and t_ctid.
7541 * t_self is the normal place, but if the tuple is converted to a
7542 * composite Datum, t_self will be lost; setting t_ctid allows CTID to be
7543 * preserved during EvalPlanQual re-evaluations (see ROW_MARK_COPY code).
7544 */
7548 /*
7549 * Stomp on the xmin, xmax, and cmin fields from the tuple created by
7550 * heap_form_tuple. heap_form_tuple actually creates the tuple with
7551 * DatumTupleFields, not HeapTupleFields, but the executor expects
7552 * HeapTupleFields and will happily extract system columns on that
7553 * assumption. If we don't do this then, for example, the tuple length
7554 * ends up in the xmin field, which isn't what we want.
7555 */
7560 /* Clean up */
7564 }
7566 /*
7567 * Callback function which is called when error occurs during column value
7568 * conversion. Print names of column and relation.
7569 *
7570 * Note that this function mustn't do any catalog lookups, since we are in
7571 * an already-failed transaction. Fortunately, we can get the needed info
7572 * from the relation or the query's rangetable instead.
7573 */
7574 static void
7576 {
7584 /*
7585 * If we're in a scan node, always use aliases from the rangetable, for
7586 * consistency between the simple-relation and remote-join cases. Look at
7587 * the relation's tupdesc only if we're not in a scan node.
7588 */
7590 {
7591 /* ForeignScan case */
7597 {
7598 /* error occurred in a scan against a foreign table */
7601 }
7602 else
7603 {
7604 /* error occurred in a scan against a foreign join */
7610 /*
7611 * Target list can have Vars and expressions. For Vars, we can
7612 * get some information, however for expressions we can't. Thus
7613 * for expressions, just show generic context message.
7614 */
7616 {
7621 }
7622 }
7625 {
7637 }
7638 }
7640 {
7641 /* Non-ForeignScan case (we should always have a rel here) */
7646 {
7651 }
7654 }
7660 else
7663 }
7665 /*
7666 * Given an EquivalenceClass and a foreign relation, find an EC member
7667 * that can be used to sort the relation remotely according to a pathkey
7668 * using this EC.
7669 *
7670 * If there is more than one suitable candidate, return an arbitrary
7671 * one of them. If there is none, return NULL.
7672 *
7673 * This checks that the EC member expression uses only Vars from the given
7674 * rel and is shippable. Caller must separately verify that the pathkey's
7675 * ordering operator is shippable.
7676 */
7677 EquivalenceMember *
7679 {
7683 {
7686 /*
7687 * Note we require !bms_is_empty, else we'd accept constant
7688 * expressions which are not suitable for the purpose.
7689 */
7694 }
7697 }
7699 /*
7700 * Find an EquivalenceClass member that is to be computed as a sort column
7701 * in the given rel's reltarget, and is shippable.
7702 *
7703 * If there is more than one suitable candidate, return an arbitrary
7704 * one of them. If there is none, return NULL.
7705 *
7706 * This checks that the EC member expression uses only Vars from the given
7707 * rel and is shippable. Caller must separately verify that the pathkey's
7708 * ordering operator is shippable.
7709 */
7710 EquivalenceMember *
7713 {
7720 {
7725 /* Ignore non-sort expressions */
7729 {
7730 i++;
7732 }
7734 /* We ignore binary-compatible relabeling on both ends */
7738 /* Locate an EquivalenceClass member matching this expr, if any */
7740 {
7744 /* Don't match constants */
7748 /* Ignore child members */
7752 /* Match if same expression (after stripping relabel) */
7760 /* Check that expression (including relabels!) is shippable */
7763 }
7765 i++;
7766 }
7769 }
7771 /*
7772 * Determine batch size for a given foreign table. The option specified for
7773 * a table has precedence.
7774 */
7775 static int
7777 {
7784 /* we use 1 by default, which means "no batching" */
7787 /*
7788 * Load options for table and server. We append server options after table
7789 * options, because table options take precedence.
7790 */
7798 /* See if either table or server specifies batch_size. */
7800 {
7804 {
7807 }
7808 }
7811 }