Loading...
Searching...
No Matches
postgres_fdw.c File Reference
#include "postgres.h"#include <limits.h>#include "access/htup_details.h"#include "access/sysattr.h"#include "access/table.h"#include "catalog/pg_opfamily.h"#include "commands/defrem.h"#include "commands/explain_format.h"#include "commands/explain_state.h"#include "executor/execAsync.h"#include "foreign/fdwapi.h"#include "funcapi.h"#include "miscadmin.h"#include "nodes/makefuncs.h"#include "nodes/nodeFuncs.h"#include "optimizer/appendinfo.h"#include "optimizer/cost.h"#include "optimizer/inherit.h"#include "optimizer/optimizer.h"#include "optimizer/pathnode.h"#include "optimizer/paths.h"#include "optimizer/planmain.h"#include "optimizer/prep.h"#include "optimizer/restrictinfo.h"#include "optimizer/tlist.h"#include "parser/parsetree.h"#include "postgres_fdw.h"#include "storage/latch.h"#include "utils/builtins.h"#include "utils/float.h"#include "utils/guc.h"#include "utils/lsyscache.h"#include "utils/memutils.h"#include "utils/rel.h"#include "utils/sampling.h"#include "utils/selfuncs.h"
Include dependency graph for postgres_fdw.c:
Go to the source code of this file.
Data Structures | |
| struct | PgFdwScanState |
| struct | PgFdwModifyState |
| struct | PgFdwDirectModifyState |
| struct | PgFdwAnalyzeState |
| struct | PgFdwPathExtraData |
| struct | ConversionLocation |
| struct | ec_member_foreign_arg |
Macros | |
| #define | DEFAULT_FDW_STARTUP_COST 100.0 |
| #define | DEFAULT_FDW_TUPLE_COST 0.2 |
| #define | DEFAULT_FDW_SORT_MULTIPLIER 1.2 |
Macro Definition Documentation
◆ DEFAULT_FDW_SORT_MULTIPLIER
| #define DEFAULT_FDW_SORT_MULTIPLIER 1.2 |
Definition at line 64 of file postgres_fdw.c.
◆ DEFAULT_FDW_STARTUP_COST
| #define DEFAULT_FDW_STARTUP_COST 100.0 |
Definition at line 58 of file postgres_fdw.c.
◆ DEFAULT_FDW_TUPLE_COST
| #define DEFAULT_FDW_TUPLE_COST 0.2 |
Definition at line 61 of file postgres_fdw.c.
Typedef Documentation
◆ ConversionLocation
◆ PgFdwAnalyzeState
◆ PgFdwDirectModifyState
◆ PgFdwModifyState
◆ PgFdwScanState
Enumeration Type Documentation
◆ FdwDirectModifyPrivateIndex
| Enumerator | |
|---|---|
| FdwDirectModifyPrivateUpdateSql | |
| FdwDirectModifyPrivateHasReturning | |
| FdwDirectModifyPrivateRetrievedAttrs | |
| FdwDirectModifyPrivateSetProcessed | |
Definition at line 124 of file postgres_fdw.c.
125{
126 /* SQL statement to execute remotely (as a String node) */
128 /* has-returning flag (as a Boolean node) */
130 /* Integer list of attribute numbers retrieved by RETURNING */
132 /* set-processed flag (as a Boolean node) */
134};
@ FdwDirectModifyPrivateRetrievedAttrs
Definition postgres_fdw.c:131
◆ FdwModifyPrivateIndex
| Enumerator | |
|---|---|
| FdwModifyPrivateUpdateSql | |
| FdwModifyPrivateTargetAttnums | |
| FdwModifyPrivateLen | |
| FdwModifyPrivateHasReturning | |
| FdwModifyPrivateRetrievedAttrs | |
Definition at line 101 of file postgres_fdw.c.
102{
103 /* SQL statement to execute remotely (as a String node) */
105 /* Integer list of target attribute numbers for INSERT/UPDATE */
107 /* Length till the end of VALUES clause (as an Integer node) */
108 FdwModifyPrivateLen,
109 /* has-returning flag (as a Boolean node) */
111 /* Integer list of attribute numbers retrieved by RETURNING */
113};
◆ FdwPathPrivateIndex
| Enumerator | |
|---|---|
| FdwPathPrivateHasFinalSort | |
| FdwPathPrivateHasLimit | |
Definition at line 284 of file postgres_fdw.c.
285{
286 /* has-final-sort flag (as a Boolean node) */
288 /* has-limit flag (as a Boolean node) */
290};
◆ FdwScanPrivateIndex
| Enumerator | |
|---|---|
| FdwScanPrivateSelectSql | |
| FdwScanPrivateRetrievedAttrs | |
| FdwScanPrivateFetchSize | |
| FdwScanPrivateRelations | |
Definition at line 73 of file postgres_fdw.c.
74{
75 /* SQL statement to execute remotely (as a String node) */
77 /* Integer list of attribute numbers retrieved by the SELECT */
79 /* Integer representing the desired fetch_size */
81
82 /*
83 * String describing join i.e. names of relations being joined and types
84 * of join, added when the scan is join
85 */
87};
Function Documentation
◆ add_foreign_final_paths()
|
static |
Definition at line 6935 of file postgres_fdw.c.
6938{
6942 bool has_final_sort = false;
6946 double rows;
6947 int width;
6948 int disabled_nodes;
6949 Cost startup_cost;
6950 Cost total_cost;
6951 List *fdw_private;
6953
6954 /*
6955 * Currently, we only support this for SELECT commands
6956 */
6958 return;
6959
6960 /*
6961 * No work if there is no FOR UPDATE/SHARE clause and if there is no need
6962 * to add a LIMIT node
6963 */
6965 return;
6966
6967 /* We don't support cases where there are any SRFs in the targetlist */
6969 return;
6970
6971 /* Save the input_rel as outerrel in fpinfo */
6973
6974 /*
6975 * Copy foreign table, foreign server, user mapping, FDW options etc.
6976 * details from the input relation's fpinfo.
6977 */
6982
6983 /*
6984 * If there is no need to add a LIMIT node, there might be a ForeignPath
6985 * in the input_rel's pathlist that implements all behavior of the query.
6986 * Note: we would already have accounted for the query's FOR UPDATE/SHARE
6987 * (if any) before we get here.
6988 */
6990 {
6992
6994
6995 /*
6996 * Grouping and aggregation are not supported with FOR UPDATE/SHARE,
6997 * so the input_rel should be a base, join, or ordered relation; and
6998 * if it's an ordered relation, its input relation should be a base or
6999 * join relation.
7000 */
7007
7009 {
7011
7012 /*
7013 * apply_scanjoin_target_to_paths() uses create_projection_path()
7014 * to adjust each of its input paths if needed, whereas
7015 * create_ordered_paths() uses apply_projection_to_path() to do
7016 * that. So the former might have put a ProjectionPath on top of
7017 * the ForeignPath; look through ProjectionPath and see if the
7018 * path underneath it is ForeignPath.
7019 */
7023 {
7024 /*
7025 * Create foreign final path; this gets rid of a
7026 * no-longer-needed outer plan (if any), which makes the
7027 * EXPLAIN output look cleaner
7028 */
7030 path->parent,
7031 path->pathtarget,
7032 path->rows,
7033 path->disabled_nodes,
7034 path->startup_cost,
7035 path->total_cost,
7036 path->pathkeys,
7039 * list */
7041
7042 /* and add it to the final_rel */
7044
7045 /* Safe to push down */
7047
7048 return;
7049 }
7050 }
7051
7052 /*
7053 * If we get here it means no ForeignPaths; since we would already
7054 * have considered pushing down all operations for the query to the
7055 * remote server, give up on it.
7056 */
7057 return;
7058 }
7059
7061
7062 /*
7063 * If the input_rel is an ordered relation, replace the input_rel with its
7064 * input relation
7065 */
7068 {
7071 has_final_sort = true;
7072 pathkeys = root->sort_pathkeys;
7073 }
7074
7075 /* The input_rel should be a base, join, or grouping relation */
7080
7081 /*
7082 * We try to create a path below by extending a simple foreign path for
7083 * the underlying base, join, or grouping relation to perform the final
7084 * sort (if has_final_sort) and the LIMIT restriction remotely, which is
7085 * stored into the fdw_private list of the resulting path. (We
7086 * re-estimate the costs of sorting the underlying relation, if
7087 * has_final_sort.)
7088 */
7089
7090 /*
7091 * Assess if it is safe to push down the LIMIT and OFFSET to the remote
7092 * server
7093 */
7094
7095 /*
7096 * If the underlying relation has any local conditions, the LIMIT/OFFSET
7097 * cannot be pushed down.
7098 */
7100 return;
7101
7102 /*
7103 * If the query has FETCH FIRST .. WITH TIES, 1) it must have ORDER BY as
7104 * well, which is used to determine which additional rows tie for the last
7105 * place in the result set, and 2) ORDER BY must already have been
7106 * determined to be safe to push down before we get here. So in that case
7107 * the FETCH clause is safe to push down with ORDER BY if the remote
7108 * server is v13 or later, but if not, the remote query will fail entirely
7109 * for lack of support for it. Since we do not currently have a way to do
7110 * a remote-version check (without accessing the remote server), disable
7111 * pushing the FETCH clause for now.
7112 */
7114 return;
7115
7116 /*
7117 * Also, the LIMIT/OFFSET cannot be pushed down, if their expressions are
7118 * not safe to remote.
7119 */
7122 return;
7123
7124 /* Safe to push down */
7126
7127 /* Construct PgFdwPathExtraData */
7130 fpextra->has_final_sort = has_final_sort;
7135
7136 /*
7137 * Estimate the costs of performing the final sort and the LIMIT
7138 * restriction remotely. If has_final_sort is false, we wouldn't need to
7139 * execute EXPLAIN anymore if use_remote_estimate, since the costs can be
7140 * roughly estimated using the costs we already have for the underlying
7141 * relation, in the same way as when use_remote_estimate is false. Since
7142 * it's pretty expensive to execute EXPLAIN, force use_remote_estimate to
7143 * false in that case.
7144 */
7146 {
7149 }
7151 &rows, &width, &disabled_nodes,
7152 &startup_cost, &total_cost);
7155
7156 /*
7157 * Build the fdw_private list that will be used by postgresGetForeignPlan.
7158 * Items in the list must match order in enum FdwPathPrivateIndex.
7159 */
7162
7163 /*
7164 * Create foreign final path; this gets rid of a no-longer-needed outer
7165 * plan (if any), which makes the EXPLAIN output look cleaner
7166 */
7168 input_rel,
7170 rows,
7171 disabled_nodes,
7172 startup_cost,
7173 total_cost,
7174 pathkeys,
7177 fdw_private);
7178
7179 /* and add it to the final_rel */
7181}
bool is_foreign_expr(PlannerInfo *root, RelOptInfo *baserel, Expr *expr)
Definition deparse.c:244
ForeignPath * create_foreign_upper_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
Definition pathnode.c:2174
static void estimate_path_cost_size(PlannerInfo *root, RelOptInfo *foreignrel, List *param_join_conds, List *pathkeys, PgFdwPathExtraData *fpextra, double *p_rows, int *p_width, int *p_disabled_nodes, Cost *p_startup_cost, Cost *p_total_cost)
Definition postgres_fdw.c:3089
static void merge_fdw_options(PgFdwRelationInfo *fpinfo, const PgFdwRelationInfo *fpinfo_o, const PgFdwRelationInfo *fpinfo_i)
Definition postgres_fdw.c:6202
Definition primnodes.h:189
Definition pathnodes.h:2194
Definition pg_list.h:54
Definition pathnodes.h:1945
Definition postgres_fdw.c:294
Definition postgres_fdw.h:31
Definition pathnodes.h:2480
Definition parsenodes.h:118
Definition pg_list.h:46
References add_path(), Assert, CMD_SELECT, FinalPathExtraData::count_est, create_foreign_upper_path(), Path::disabled_nodes, estimate_path_cost_size(), fb(), is_foreign_expr(), IsA, lfirst, FinalPathExtraData::limit_needed, LIMIT_OPTION_WITH_TIES, FinalPathExtraData::limit_tuples, list_make2, makeBoolean(), merge_fdw_options(), NIL, FinalPathExtraData::offset_est, palloc0_object, parse(), Path::pathkeys, RELOPT_BASEREL, RELOPT_JOINREL, RELOPT_UPPER_REL, root, Path::rows, Path::startup_cost, subpath(), Path::total_cost, UPPERREL_FINAL, UPPERREL_GROUP_AGG, and UPPERREL_ORDERED.
Referenced by postgresGetForeignUpperPaths().
◆ add_foreign_grouping_paths()
|
static |
Definition at line 6701 of file postgres_fdw.c.
6704{
6709 double rows;
6710 int width;
6711 int disabled_nodes;
6712 Cost startup_cost;
6713 Cost total_cost;
6714
6715 /* Nothing to be done, if there is no grouping or aggregation required. */
6717 !root->hasHavingQual)
6718 return;
6719
6722
6723 /* save the input_rel as outerrel in fpinfo */
6725
6726 /*
6727 * Copy foreign table, foreign server, user mapping, FDW options etc.
6728 * details from the input relation's fpinfo.
6729 */
6734
6735 /*
6736 * Assess if it is safe to push down aggregation and grouping.
6737 *
6738 * Use HAVING qual from extra. In case of child partition, it will have
6739 * translated Vars.
6740 */
6742 return;
6743
6744 /*
6745 * Compute the selectivity and cost of the local_conds, so we don't have
6746 * to do it over again for each path. (Currently we create just a single
6747 * path here, but in future it would be possible that we build more paths
6748 * such as pre-sorted paths as in postgresGetForeignPaths and
6749 * postgresGetForeignJoinPaths.) The best we can do for these conditions
6750 * is to estimate selectivity on the basis of local statistics.
6751 */
6753 fpinfo->local_conds,
6754 0,
6755 JOIN_INNER,
6756 NULL);
6757
6759
6760 /* Estimate the cost of push down */
6762 &rows, &width, &disabled_nodes,
6763 &startup_cost, &total_cost);
6764
6765 /* Now update this information in the fpinfo */
6766 fpinfo->rows = rows;
6767 fpinfo->width = width;
6768 fpinfo->disabled_nodes = disabled_nodes;
6769 fpinfo->startup_cost = startup_cost;
6770 fpinfo->total_cost = total_cost;
6771
6772 /* Create and add foreign path to the grouping relation. */
6774 grouped_rel,
6775 grouped_rel->reltarget,
6776 rows,
6777 disabled_nodes,
6778 startup_cost,
6779 total_cost,
6781 NULL,
6784
6785 /* Add generated path into grouped_rel by add_path(). */
6787}
Selectivity clauselist_selectivity(PlannerInfo *root, List *clauses, int varRelid, JoinType jointype, SpecialJoinInfo *sjinfo)
Definition clausesel.c:100
void cost_qual_eval(QualCost *cost, List *quals, PlannerInfo *root)
Definition costsize.c:4903
static bool foreign_grouping_ok(PlannerInfo *root, RelOptInfo *grouped_rel, Node *havingQual)
Definition postgres_fdw.c:6408
References add_path(), Assert, clauselist_selectivity(), cost_qual_eval(), create_foreign_upper_path(), estimate_path_cost_size(), fb(), foreign_grouping_ok(), GroupPathExtraData::havingQual, JOIN_INNER, merge_fdw_options(), NIL, parse(), PARTITIONWISE_AGGREGATE_FULL, PARTITIONWISE_AGGREGATE_NONE, GroupPathExtraData::patype, RelOptInfo::reltarget, and root.
Referenced by postgresGetForeignUpperPaths().
◆ add_foreign_ordered_paths()
|
static |
Definition at line 6797 of file postgres_fdw.c.
6799{
6804 double rows;
6805 int width;
6806 int disabled_nodes;
6807 Cost startup_cost;
6808 Cost total_cost;
6809 List *fdw_private;
6812
6813 /* Shouldn't get here unless the query has ORDER BY */
6815
6816 /* We don't support cases where there are any SRFs in the targetlist */
6818 return;
6819
6820 /* Save the input_rel as outerrel in fpinfo */
6822
6823 /*
6824 * Copy foreign table, foreign server, user mapping, FDW options etc.
6825 * details from the input relation's fpinfo.
6826 */
6831
6832 /*
6833 * If the input_rel is a base or join relation, we would already have
6834 * considered pushing down the final sort to the remote server when
6835 * creating pre-sorted foreign paths for that relation, because the
6836 * query_pathkeys is set to the root->sort_pathkeys in that case (see
6837 * standard_qp_callback()).
6838 */
6841 {
6843
6844 /* Safe to push down if the query_pathkeys is safe to push down */
6846
6847 return;
6848 }
6849
6850 /* The input_rel should be a grouping relation */
6853
6854 /*
6855 * We try to create a path below by extending a simple foreign path for
6856 * the underlying grouping relation to perform the final sort remotely,
6857 * which is stored into the fdw_private list of the resulting path.
6858 */
6859
6860 /* Assess if it is safe to push down the final sort */
6862 {
6865
6866 /*
6867 * is_foreign_expr would detect volatile expressions as well, but
6868 * checking ec_has_volatile here saves some cycles.
6869 */
6871 return;
6872
6873 /*
6874 * Can't push down the sort if pathkey's opfamily is not shippable.
6875 */
6877 fpinfo))
6878 return;
6879
6880 /*
6881 * The EC must contain a shippable EM that is computed in input_rel's
6882 * reltarget, else we can't push down the sort.
6883 */
6885 pathkey_ec,
6887 return;
6888 }
6889
6890 /* Safe to push down */
6892
6893 /* Construct PgFdwPathExtraData */
6897
6898 /* Estimate the costs of performing the final sort remotely */
6900 &rows, &width, &disabled_nodes,
6901 &startup_cost, &total_cost);
6902
6903 /*
6904 * Build the fdw_private list that will be used by postgresGetForeignPlan.
6905 * Items in the list must match order in enum FdwPathPrivateIndex.
6906 */
6908
6909 /* Create foreign ordering path */
6911 input_rel,
6913 rows,
6914 disabled_nodes,
6915 startup_cost,
6916 total_cost,
6917 root->sort_pathkeys,
6920 * list */
6921 fdw_private);
6922
6923 /* and add it to the ordered_rel */
6925}
EquivalenceMember * find_em_for_rel_target(PlannerInfo *root, EquivalenceClass *ec, RelOptInfo *rel)
Definition postgres_fdw.c:7786
bool is_shippable(Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo)
Definition shippable.c:162
Definition pathnodes.h:1634
Definition pathnodes.h:1787
References add_path(), Assert, create_foreign_upper_path(), estimate_path_cost_size(), fb(), find_em_for_rel_target(), is_shippable(), lfirst, list_make2, makeBoolean(), merge_fdw_options(), NIL, palloc0_object, parse(), RELOPT_BASEREL, RELOPT_JOINREL, RELOPT_UPPER_REL, root, UPPERREL_GROUP_AGG, and UPPERREL_ORDERED.
Referenced by postgresGetForeignUpperPaths().
◆ add_paths_with_pathkeys_for_rel()
|
static |
Definition at line 6020 of file postgres_fdw.c.
6022{
6025
6027
6028 /*
6029 * Before creating sorted paths, arrange for the passed-in EPQ path, if
6030 * any, to return columns needed by the parent ForeignScan node so that
6031 * they will propagate up through Sort nodes injected below, if necessary.
6032 */
6034 {
6037
6038 /* Include columns required for evaluating PHVs in the tlist. */
6039 add_new_columns_to_pathtarget(target,
6041 PVC_RECURSE_PLACEHOLDERS));
6042
6043 /* Include columns required for evaluating the local conditions. */
6045 {
6047
6048 add_new_columns_to_pathtarget(target,
6050 PVC_RECURSE_PLACEHOLDERS));
6051 }
6052
6053 /*
6054 * If we have added any new columns, adjust the tlist of the EPQ path.
6055 *
6056 * Note: the plan created using this path will only be used to execute
6057 * EPQ checks, where accuracy of the plan cost and width estimates
6058 * would not be important, so we do not do set_pathtarget_cost_width()
6059 * for the new pathtarget here. See also postgresGetForeignPlan().
6060 */
6062 {
6063 /* The EPQ path is a join path, so it is projection-capable. */
6065
6066 /*
6067 * Use create_projection_path() here, so as to avoid modifying it
6068 * in place.
6069 */
6071 rel,
6072 epq_path,
6073 target);
6074 }
6075 }
6076
6077 /* Create one path for each set of pathkeys we found above. */
6079 {
6080 double rows;
6081 int width;
6082 int disabled_nodes;
6083 Cost startup_cost;
6084 Cost total_cost;
6087
6089 &rows, &width, &disabled_nodes,
6090 &startup_cost, &total_cost);
6091
6092 /*
6093 * The EPQ path must be at least as well sorted as the path itself, in
6094 * case it gets used as input to a mergejoin.
6095 */
6099 sorted_epq_path->pathkeys))
6102 rel,
6103 sorted_epq_path,
6104 useful_pathkeys,
6105 -1.0);
6106
6110 NULL,
6111 rows,
6112 disabled_nodes,
6113 startup_cost,
6114 total_cost,
6115 useful_pathkeys,
6116 rel->lateral_relids,
6117 sorted_epq_path,
6119 * list */
6120 NIL));
6121 else
6124 NULL,
6125 rows,
6126 disabled_nodes,
6127 startup_cost,
6128 total_cost,
6129 useful_pathkeys,
6130 rel->lateral_relids,
6131 sorted_epq_path,
6132 restrictlist,
6133 NIL));
6134 }
6135}
ProjectionPath * create_projection_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, PathTarget *target)
Definition pathnode.c:2531
SortPath * create_sort_path(PlannerInfo *root, RelOptInfo *rel, Path *subpath, List *pathkeys, double limit_tuples)
Definition pathnode.c:2848
ForeignPath * create_foreignscan_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
Definition pathnode.c:2072
ForeignPath * create_foreign_join_path(PlannerInfo *root, RelOptInfo *rel, PathTarget *target, double rows, int disabled_nodes, Cost startup_cost, Cost total_cost, List *pathkeys, Relids required_outer, Path *fdw_outerpath, List *fdw_restrictinfo, List *fdw_private)
Definition pathnode.c:2120
static List * get_useful_pathkeys_for_relation(PlannerInfo *root, RelOptInfo *rel)
Definition postgres_fdw.c:909
Definition nodes.h:135
Definition pathnodes.h:1852
Definition pathnodes.h:2864
void add_new_columns_to_pathtarget(PathTarget *target, List *exprs)
Definition tlist.c:761
References add_new_columns_to_pathtarget(), add_path(), Assert, RestrictInfo::clause, copy_pathtarget(), create_foreign_join_path(), create_foreignscan_path(), create_projection_path(), create_sort_path(), estimate_path_cost_size(), PathTarget::exprs, fb(), get_useful_pathkeys_for_relation(), is_projection_capable_path(), IS_SIMPLE_REL, RelOptInfo::lateral_relids, lfirst, lfirst_node, list_length(), NIL, pathkeys_contained_in(), pull_var_clause(), PVC_RECURSE_PLACEHOLDERS, and root.
Referenced by postgresGetForeignJoinPaths(), and postgresGetForeignPaths().
◆ adjust_foreign_grouping_path_cost()
|
static |
Definition at line 3640 of file postgres_fdw.c.
3648{
3649 /*
3650 * If the GROUP BY clause isn't sort-able, the plan chosen by the remote
3651 * side is unlikely to generate properly-sorted output, so it would need
3652 * an explicit sort; adjust the given costs with cost_sort(). Likewise,
3653 * if the GROUP BY clause is sort-able but isn't a superset of the given
3654 * pathkeys, adjust the costs with that function. Otherwise, adjust the
3655 * costs by applying the same heuristic as for the scan or join case.
3656 */
3659 {
3661
3663 root,
3664 pathkeys,
3665 0,
3667 retrieved_rows,
3668 width,
3669 0.0,
3670 work_mem,
3671 limit_tuples);
3672
3675 }
3676 else
3677 {
3678 /*
3679 * The default extra cost seems too large for foreign-grouping cases;
3680 * add 1/4th of that default.
3681 */
3683 - 1.0) * 0.25;
3684
3687 }
3688}
void cost_sort(Path *path, PlannerInfo *root, List *pathkeys, int input_disabled_nodes, Cost input_cost, double tuples, int width, Cost comparison_cost, int sort_mem, double limit_tuples)
Definition costsize.c:2200
References cost_sort(), DEFAULT_FDW_SORT_MULTIPLIER, fb(), grouping_is_sortable(), pathkeys_contained_in(), root, and work_mem.
Referenced by estimate_path_cost_size().
◆ analyze_row_processor()
|
static |
Definition at line 5306 of file postgres_fdw.c.
5307{
5309 int pos; /* array index to store tuple in */
5310 MemoryContext oldcontext;
5311
5312 /* Always increment sample row counter. */
5313 astate->samplerows += 1;
5314
5315 /*
5316 * Determine the slot where this sample row should be stored. Set pos to
5317 * negative value to indicate the row should be skipped.
5318 */
5320 {
5321 /* First targrows rows are always included into the sample */
5322 pos = astate->numrows++;
5323 }
5324 else
5325 {
5326 /*
5327 * Now we start replacing tuples in the sample until we reach the end
5328 * of the relation. Same algorithm as in acquire_sample_rows in
5329 * analyze.c; see Jeff Vitter's paper.
5330 */
5333
5335 {
5336 /* Choose a random reservoir element to replace. */
5338 Assert(pos >= 0 && pos < targrows);
5340 }
5341 else
5342 {
5343 /* Skip this tuple. */
5344 pos = -1;
5345 }
5346
5347 astate->rowstoskip -= 1;
5348 }
5349
5350 if (pos >= 0)
5351 {
5352 /*
5353 * Create sample tuple from current result row, and store it in the
5354 * position determined above. The tuple has to be created in anl_cxt.
5355 */
5357
5359 astate->rel,
5360 astate->attinmeta,
5361 astate->retrieved_attrs,
5362 NULL,
5363 astate->temp_cxt);
5364
5365 MemoryContextSwitchTo(oldcontext);
5366 }
5367}
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:124
static HeapTuple make_tuple_from_result_row(PGresult *res, int row, Relation rel, AttInMetadata *attinmeta, List *retrieved_attrs, ForeignScanState *fsstate, MemoryContext temp_context)
Definition postgres_fdw.c:7491
double reservoir_get_next_S(ReservoirState rs, double t, int n)
Definition sampling.c:147
Definition memnodes.h:118
References PgFdwAnalyzeState::anl_cxt, Assert, PgFdwAnalyzeState::attinmeta, fb(), heap_freetuple(), make_tuple_from_result_row(), MemoryContextSwitchTo(), PgFdwAnalyzeState::numrows, ReservoirStateData::randstate, PgFdwAnalyzeState::rel, reservoir_get_next_S(), PgFdwAnalyzeState::retrieved_attrs, PgFdwAnalyzeState::rows, PgFdwAnalyzeState::rowstoskip, PgFdwAnalyzeState::rstate, sampler_random_fract(), PgFdwAnalyzeState::samplerows, PgFdwAnalyzeState::targrows, and PgFdwAnalyzeState::temp_cxt.
Referenced by postgresAcquireSampleRowsFunc().
◆ apply_returning_filter()
|
static |
Definition at line 4705 of file postgres_fdw.c.
4709{
4713 bool *isnull;
4717
4718 /*
4719 * Use the return tuple slot as a place to store the result tuple.
4720 */
4722
4723 /*
4724 * Extract all the values of the scan tuple.
4725 */
4726 slot_getallattrs(slot);
4729
4730 /*
4731 * Prepare to build the result tuple.
4732 */
4735 isnull = resultSlot->tts_isnull;
4736
4737 /*
4738 * Transpose data into proper fields of the result tuple.
4739 */
4741 {
4743
4745 {
4748 }
4749 else
4750 {
4753 }
4754 }
4755
4756 /*
4757 * Build the virtual tuple.
4758 */
4760
4761 /*
4762 * If we have any system columns to return, materialize a heap tuple in
4763 * the slot from column values set above and install system columns in
4764 * that tuple.
4765 */
4767 {
4769
4770 /* ctid */
4772 {
4774
4776 resultTup->t_self = *ctid;
4777 }
4778
4779 /*
4780 * And remaining columns
4781 *
4782 * Note: since we currently don't allow the target relation to appear
4783 * on the nullable side of an outer join, any system columns wouldn't
4784 * go to NULL.
4785 *
4786 * Note: no need to care about tableoid here because it will be
4787 * initialized in ExecProcessReturning().
4788 */
4792 }
4793
4794 /*
4795 * And return the result tuple.
4796 */
4798}
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
Definition execTuples.c:1741
HeapTuple ExecFetchSlotHeapTuple(TupleTableSlot *slot, bool materialize, bool *shouldFree)
Definition execTuples.c:1833
TupleTableSlot * ExecGetReturningSlot(EState *estate, ResultRelInfo *relInfo)
Definition execUtils.c:1248
static void HeapTupleHeaderSetCmin(HeapTupleHeaderData *tup, CommandId cid)
Definition htup_details.h:422
static void HeapTupleHeaderSetXmin(HeapTupleHeaderData *tup, TransactionId xid)
Definition htup_details.h:331
static void HeapTupleHeaderSetXmax(HeapTupleHeaderData *tup, TransactionId xid)
Definition htup_details.h:383
Definition htup.h:63
Definition itemptr.h:37
Definition tupdesc.h:136
Definition tuptable.h:114
References DatumGetPointer(), ExecClearTuple(), ExecFetchSlotHeapTuple(), ExecGetReturningSlot(), ExecStoreVirtualTuple(), fb(), HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), i, InvalidTransactionId, j, RelationGetDescr, slot_getallattrs(), TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, and values.
Referenced by get_returning_data().
◆ apply_server_options()
|
static |
Definition at line 6143 of file postgres_fdw.c.
6144{
6146
6148 {
6150
6155 NULL);
6158 NULL);
6160 fpinfo->shippable_extensions =
6166 }
6167}
List * ExtractExtensionList(const char *extensionsString, bool warnOnMissing)
Definition option.c:445
bool parse_int(const char *value, int *result, int flags, const char **hintmsg)
Definition guc.c:2743
bool parse_real(const char *value, double *result, int flags, const char **hintmsg)
Definition guc.c:2833
Definition parsenodes.h:841
References defGetBoolean(), defGetString(), DefElem::defname, ExtractExtensionList(), fb(), lfirst, parse_int(), and parse_real().
Referenced by postgresGetForeignRelSize().
◆ apply_table_options()
|
static |
Definition at line 6175 of file postgres_fdw.c.
6176{
6178
6180 {
6182
6189 }
6190}
References defGetBoolean(), defGetString(), DefElem::defname, fb(), lfirst, and parse_int().
Referenced by postgresGetForeignRelSize().
◆ build_remote_returning()
Definition at line 4388 of file postgres_fdw.c.
4389{
4394
4395 Assert(returningList);
4396
4398
4399 /*
4400 * If there's a whole-row reference to the target relation, then we'll
4401 * need all the columns of the relation.
4402 */
4404 {
4406
4408 var->varno == rtindex &&
4410 {
4412 break;
4413 }
4414 }
4415
4417 {
4420
4422 {
4424 Var *var;
4425
4426 /* Ignore dropped attributes. */
4427 if (attr->attisdropped)
4428 continue;
4429
4430 var = makeVar(rtindex,
4431 i,
4432 attr->atttypid,
4433 attr->atttypmod,
4434 attr->attcollation,
4435 0);
4436
4437 tlist = lappend(tlist,
4439 list_length(tlist) + 1,
4440 NULL,
4441 false));
4442 }
4443 }
4444
4445 /* Now add any remaining columns to tlist. */
4447 {
4449
4450 /*
4451 * No need for whole-row references to the target relation. We don't
4452 * need system columns other than ctid and oid either, since those are
4453 * set locally.
4454 */
4456 var->varno == rtindex &&
4459 continue; /* don't need it */
4460
4462 continue; /* already got it */
4463
4464 tlist = lappend(tlist,
4466 list_length(tlist) + 1,
4467 NULL,
4468 false));
4469 }
4470
4472
4473 return tlist;
4474}
Var * makeVar(int varno, AttrNumber varattno, Oid vartype, int32 vartypmod, Oid varcollid, Index varlevelsup)
Definition makefuncs.c:66
TargetEntry * makeTargetEntry(Expr *expr, AttrNumber resno, char *resname, bool resjunk)
Definition makefuncs.c:289
Definition primnodes.h:262
Definition regcomp.c:282
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:160
References Assert, fb(), i, InvalidAttrNumber, IsA, lappend(), lfirst, list_free(), list_length(), makeTargetEntry(), makeVar(), TupleDescData::natts, NIL, pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, RelationGetDescr, SelfItemPointerAttributeNumber, tlist_member(), TupleDescAttr(), Var::varattno, and Var::varno.
Referenced by postgresPlanDirectModify().
◆ close_cursor()
|
static |
Definition at line 3938 of file postgres_fdw.c.
3940{
3941 char sql[64];
3942 PGresult *res;
3943
3948 PQclear(res);
3949}
PGresult * pgfdw_exec_query(PGconn *conn, const char *query, PgFdwConnState *state)
Definition connection.c:947
void pgfdw_report_error(PGresult *res, PGconn *conn, const char *sql)
Definition connection.c:988
Definition libpq-int.h:165
References conn, cursor_number, pgfdw_exec_query(), pgfdw_report_error(), PGRES_COMMAND_OK, PQclear, PQresultStatus, and snprintf.
Referenced by postgresAcquireSampleRowsFunc(), and postgresEndForeignScan().
◆ complete_pending_request()
|
static |
Definition at line 7457 of file postgres_fdw.c.
7458{
7459 /* The request would have been pending for a callback */
7461
7462 /* Unlike AsyncNotify, we unset callback_pending ourselves */
7464
7465 /* We begin a fetch afterwards if necessary; don't fetch */
7467
7468 /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
7470
7471 /* Also, we do instrumentation ourselves, if required */
7475}
void InstrUpdateTupleCount(Instrumentation *instr, double nTuples)
Definition instrument.c:132
static void produce_tuple_asynchronously(AsyncRequest *areq, bool fetch)
Definition postgres_fdw.c:7326
References Assert, ExecAsyncResponse(), fb(), InstrUpdateTupleCount(), produce_tuple_asynchronously(), and TupIsNull.
Referenced by postgresForeignAsyncConfigureWait().
◆ conversion_error_callback()
Definition at line 7648 of file postgres_fdw.c.
7649{
7656
7657 /*
7658 * If we're in a scan node, always use aliases from the rangetable, for
7659 * consistency between the simple-relation and remote-join cases. Look at
7660 * the relation's tupdesc only if we're not in a scan node.
7661 */
7662 if (fsstate)
7663 {
7664 /* ForeignScan case */
7666 int varno = 0;
7667 AttrNumber colno = 0;
7668
7670 {
7671 /* error occurred in a scan against a foreign table */
7672 varno = fsplan->scan.scanrelid;
7673 colno = errpos->cur_attno;
7674 }
7675 else
7676 {
7677 /* error occurred in a scan against a foreign join */
7679
7681 errpos->cur_attno - 1);
7682
7683 /*
7684 * Target list can have Vars and expressions. For Vars, we can
7685 * get some information, however for expressions we can't. Thus
7686 * for expressions, just show generic context message.
7687 */
7689 {
7691
7692 varno = var->varno;
7693 colno = var->varattno;
7694 }
7695 }
7696
7697 if (varno > 0)
7698 {
7701
7703
7704 if (colno == 0)
7710 }
7711 }
7712 else if (rel)
7713 {
7714 /* Non-ForeignScan case (we should always have a rel here) */
7716
7719 {
7721 errpos->cur_attno - 1);
7722
7724 }
7727 }
7728
7733 else
7735 errpos->cur_attno);
7736}
static RangeTblEntry * exec_rt_fetch(Index rti, EState *estate)
Definition executor.h:697
Definition postgres_fdw.c:307
Definition execnodes.h:657
Definition execnodes.h:2087
Definition plannodes.h:870
Definition parsenodes.h:1085
Definition rel.h:56
Definition primnodes.h:2236
References arg, attname, castNode, errcontext, exec_rt_fetch(), fb(), IsA, list_length(), list_nth(), list_nth_node, NameStr, TupleDescData::natts, PlanState::plan, ScanState::ps, RelationGetDescr, RelationGetRelationName, relname, SelfItemPointerAttributeNumber, ForeignScanState::ss, PlanState::state, strVal, TupleDescAttr(), Var::varattno, and Var::varno.
Referenced by make_tuple_from_result_row().
◆ convert_prep_stmt_params()
|
static |
Definition at line 4246 of file postgres_fdw.c.
4250{
4255 MemoryContext oldcontext;
4256
4258
4260
4261 /* ctid is provided only for UPDATE/DELETE, which don't allow batching */
4263
4264 /* 1st parameter should be ctid, if it's in use */
4266 {
4268 /* don't need set_transmission_modes for TID output */
4271 pindex++;
4272 }
4273
4274 /* get following parameters from slots */
4276 {
4280
4282
4284 {
4287 {
4291 bool isnull;
4292
4293 /* Ignore generated columns; they are set to DEFAULT */
4295 continue;
4297 if (isnull)
4299 else
4301 value);
4302 pindex++;
4303 j++;
4304 }
4305 }
4306
4308 }
4309
4311
4312 MemoryContextSwitchTo(oldcontext);
4313
4315}
static struct @172 value
Definition tupdesc.h:69
static CompactAttribute * TupleDescCompactAttr(TupleDesc tupdesc, int i)
Definition tupdesc.h:175
static Datum slot_getattr(TupleTableSlot *slot, int attnum, bool *isnull)
Definition tuptable.h:398
References Assert, CompactAttribute::attgenerated, attnum, fb(), i, j, lfirst_int, MemoryContextSwitchTo(), NIL, OutputFunctionCall(), palloc(), PointerGetDatum(), RelationGetDescr, reset_transmission_modes(), set_transmission_modes(), slot_getattr(), TupleDescCompactAttr(), and value.
Referenced by execute_foreign_modify().
◆ create_cursor()
|
static |
Definition at line 3725 of file postgres_fdw.c.
3726{
3729 int numParams = fsstate->numParams;
3733 PGresult *res;
3734
3735 /* First, process a pending asynchronous request, if any. */
3736 if (fsstate->conn_state->pendingAreq)
3737 process_pending_request(fsstate->conn_state->pendingAreq);
3738
3739 /*
3740 * Construct array of query parameter values in text format. We do the
3741 * conversions in the short-lived per-tuple context, so as not to cause a
3742 * memory leak over repeated scans.
3743 */
3744 if (numParams > 0)
3745 {
3746 MemoryContext oldcontext;
3747
3749
3750 process_query_params(econtext,
3751 fsstate->param_flinfo,
3752 fsstate->param_exprs,
3753 values);
3754
3755 MemoryContextSwitchTo(oldcontext);
3756 }
3757
3758 /* Construct the DECLARE CURSOR command */
3761 fsstate->cursor_number, fsstate->query);
3762
3763 /*
3764 * Notice that we pass NULL for paramTypes, thus forcing the remote server
3765 * to infer types for all parameters. Since we explicitly cast every
3766 * parameter (see deparse.c), the "inference" is trivial and will produce
3767 * the desired result. This allows us to avoid assuming that the remote
3768 * server has the same OIDs we do for the parameters' types.
3769 */
3773
3774 /*
3775 * Get the result, and check for success.
3776 */
3780 PQclear(res);
3781
3782 /* Mark the cursor as created, and show no tuples have been retrieved */
3783 fsstate->cursor_exists = true;
3784 fsstate->tuples = NULL;
3785 fsstate->num_tuples = 0;
3786 fsstate->next_tuple = 0;
3787 fsstate->fetch_ct_2 = 0;
3788 fsstate->eof_reached = false;
3789
3790 /* Clean up */
3792}
int PQsendQueryParams(PGconn *conn, const char *command, int nParams, const Oid *paramTypes, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
Definition fe-exec.c:1509
void process_pending_request(AsyncRequest *areq)
Definition postgres_fdw.c:7424
static void process_query_params(ExprContext *econtext, FmgrInfo *param_flinfo, List *param_exprs, const char **param_values)
Definition postgres_fdw.c:4849
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition stringinfo.c:145
Definition execnodes.h:270
Definition postgres_fdw.c:140
Definition stringinfo.h:47
Definition libpq-int.h:372
References appendStringInfo(), buf, PgFdwScanState::conn, conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_exists, PgFdwScanState::cursor_number, ExprContext::ecxt_per_tuple_memory, PgFdwScanState::eof_reached, fb(), ForeignScanState::fdw_state, PgFdwScanState::fetch_ct_2, initStringInfo(), MemoryContextSwitchTo(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, PgFdwScanState::numParams, PgFdwScanState::param_exprs, PgFdwScanState::param_flinfo, PgFdwScanState::param_values, PgFdwConnState::pendingAreq, pfree(), pgfdw_get_result(), pgfdw_report_error(), PGRES_COMMAND_OK, PQclear, PQresultStatus, PQsendQueryParams(), process_pending_request(), process_query_params(), ScanState::ps, PlanState::ps_ExprContext, PgFdwScanState::query, ForeignScanState::ss, PgFdwScanState::tuples, and values.
Referenced by fetch_more_data_begin(), and postgresIterateForeignScan().
◆ create_foreign_modify()
|
static |
Definition at line 3957 of file postgres_fdw.c.
3967{
3971 Oid userid;
3978
3979 /* Begin constructing PgFdwModifyState. */
3981 fmstate->rel = rel;
3982
3983 /* Identify which user to do the remote access as. */
3984 userid = ExecGetResultRelCheckAsUser(resultRelInfo, estate);
3985
3986 /* Get info about foreign table. */
3989
3990 /* Open connection; report that we'll create a prepared statement. */
3993
3994 /* Set up remote query information. */
3995 fmstate->query = query;
3997 {
4000 }
4001 fmstate->target_attrs = target_attrs;
4002 fmstate->values_end = values_end;
4003 fmstate->has_returning = has_returning;
4004 fmstate->retrieved_attrs = retrieved_attrs;
4005
4006 /* Create context for per-tuple temp workspace. */
4008 "postgres_fdw temporary data",
4009 ALLOCSET_SMALL_SIZES);
4010
4011 /* Prepare for input conversion of RETURNING results. */
4014
4015 /* Prepare for output conversion of parameters used in prepared stmt. */
4018 fmstate->p_nums = 0;
4019
4021 {
4023
4024 /* Find the ctid resjunk column in the subplan's result */
4026 "ctid");
4029
4030 /* First transmittable parameter will be ctid */
4033 fmstate->p_nums++;
4034 }
4035
4037 {
4038 /* Set up for remaining transmittable parameters */
4040 {
4043
4044 Assert(!attr->attisdropped);
4045
4046 /* Ignore generated columns; they are set to DEFAULT */
4047 if (attr->attgenerated)
4048 continue;
4051 fmstate->p_nums++;
4052 }
4053 }
4054
4056
4057 /* Set batch_size from foreign server/table options. */
4060
4061 fmstate->num_slots = 1;
4062
4063 /* Initialize auxiliary state */
4065
4067}
AttrNumber ExecFindJunkAttributeInTlist(List *targetlist, const char *attrName)
Definition execJunk.c:222
AttInMetadata * TupleDescGetAttInMetadata(TupleDesc tupdesc)
Definition execTuples.c:2275
Oid ExecGetResultRelCheckAsUser(ResultRelInfo *relInfo, EState *estate)
Definition execUtils.c:1489
void getTypeOutputInfo(Oid type, Oid *typOutput, bool *typIsVarlena)
Definition lsyscache.c:3057
Definition foreign.h:54
Definition postgres_fdw.c:183
Definition foreign.h:46
References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert, attnum, AttributeNumberIsValid, CMD_DELETE, CMD_INSERT, CMD_UPDATE, elog, ERROR, EState::es_query_cxt, ExecFindJunkAttributeInTlist(), ExecGetResultRelCheckAsUser(), fb(), fmgr_info(), get_batch_size_option(), GetConnection(), GetForeignTable(), getTypeOutputInfo(), GetUserMapping(), lfirst_int, list_length(), palloc0_array, palloc0_object, pstrdup(), RelationGetDescr, RelationGetRelid, ResultRelInfo::ri_RelationDesc, table, Plan::targetlist, TupleDescAttr(), TupleDescGetAttInMetadata(), and user.
Referenced by postgresBeginForeignInsert(), and postgresBeginForeignModify().
◆ deallocate_query()
|
static |
Definition at line 4364 of file postgres_fdw.c.
4365{
4366 char sql[64];
4367 PGresult *res;
4368
4369 /* do nothing if the query is not allocated */
4371 return;
4372
4377 PQclear(res);
4380}
References fb(), pfree(), pgfdw_exec_query(), pgfdw_report_error(), PGRES_COMMAND_OK, PQclear, PQresultStatus, and snprintf.
Referenced by execute_foreign_modify(), and finish_foreign_modify().
◆ ec_member_matches_foreign()
|
static |
Definition at line 3696 of file postgres_fdw.c.
3699{
3702
3703 /*
3704 * If we've identified what we're processing in the current scan, we only
3705 * want to match that expression.
3706 */
3709
3710 /*
3711 * Otherwise, ignore anything we've already processed.
3712 */
3714 return false;
3715
3716 /* This is the new target to process. */
3717 state->current = expr;
3718 return true;
3719}
Definition postgres_fdw.c:315
Definition regguts.h:323
References arg, equal(), fb(), and list_member().
Referenced by postgresGetForeignPaths().
◆ estimate_path_cost_size()
|
static |
Definition at line 3089 of file postgres_fdw.c.
3097{
3099 double rows;
3100 double retrieved_rows;
3101 int width;
3102 int disabled_nodes = 0;
3103 Cost startup_cost;
3104 Cost total_cost;
3105
3106 /* Make sure the core code has set up the relation's reltarget */
3108
3109 /*
3110 * If the table or the server is configured to use remote estimates,
3111 * connect to the foreign server and execute EXPLAIN to estimate the
3112 * number of rows selected by the restriction+join clauses. Otherwise,
3113 * estimate rows using whatever statistics we have locally, in a way
3114 * similar to ordinary tables.
3115 */
3117 {
3120 StringInfoData sql;
3125 List *remote_conds;
3126
3127 /* Required only to be passed to deparseSelectStmtForRel */
3128 List *retrieved_attrs;
3129
3130 /*
3131 * param_join_conds might contain both clauses that are safe to send
3132 * across, and clauses that aren't.
3133 */
3136
3137 /* Build the list of columns to be fetched from the foreign server. */
3139 fdw_scan_tlist = build_tlist_to_deparse(foreignrel);
3140 else
3141 fdw_scan_tlist = NIL;
3142
3143 /*
3144 * The complete list of remote conditions includes everything from
3145 * baserestrictinfo plus any extra join_conds relevant to this
3146 * particular path.
3147 */
3149 fpinfo->remote_conds);
3150
3151 /*
3152 * Construct EXPLAIN query including the desired SELECT, FROM, and
3153 * WHERE clauses. Params and other-relation Vars are replaced by dummy
3154 * values, so don't request params_list.
3155 */
3156 initStringInfo(&sql);
3159 remote_conds, pathkeys,
3163
3164 /* Get the remote estimate */
3167 &startup_cost, &total_cost);
3169
3170 retrieved_rows = rows;
3171
3172 /* Factor in the selectivity of the locally-checked quals */
3174 local_param_join_conds,
3175 foreignrel->relid,
3176 JOIN_INNER,
3177 NULL);
3179
3181
3182 /* Add in the eval cost of the locally-checked quals */
3183 startup_cost += fpinfo->local_conds_cost.startup;
3184 total_cost += fpinfo->local_conds_cost.per_tuple * retrieved_rows;
3186 startup_cost += local_cost.startup;
3187 total_cost += local_cost.per_tuple * retrieved_rows;
3188
3189 /*
3190 * Add in tlist eval cost for each output row. In case of an
3191 * aggregate, some of the tlist expressions such as grouping
3192 * expressions will be evaluated remotely, so adjust the costs.
3193 */
3198 {
3200
3202 startup_cost -= tlist_cost.startup;
3203 total_cost -= tlist_cost.startup;
3204 total_cost -= tlist_cost.per_tuple * rows;
3205 }
3206 }
3207 else
3208 {
3209 Cost run_cost = 0;
3210
3211 /*
3212 * We don't support join conditions in this mode (hence, no
3213 * parameterized paths can be made).
3214 */
3216
3217 /*
3218 * We will come here again and again with different set of pathkeys or
3219 * additional post-scan/join-processing steps that caller wants to
3220 * cost. We don't need to calculate the cost/size estimates for the
3221 * underlying scan, join, or grouping each time. Instead, use those
3222 * estimates if we have cached them already.
3223 */
3225 {
3227
3228 rows = fpinfo->rows;
3229 retrieved_rows = fpinfo->retrieved_rows;
3230 width = fpinfo->width;
3231 startup_cost = fpinfo->rel_startup_cost;
3233
3234 /*
3235 * If we estimate the costs of a foreign scan or a foreign join
3236 * with additional post-scan/join-processing steps, the scan or
3237 * join costs obtained from the cache wouldn't yet contain the
3238 * eval costs for the final scan/join target, which would've been
3239 * updated by apply_scanjoin_target_to_paths(); add the eval costs
3240 * now.
3241 */
3243 {
3244 /* Shouldn't get here unless we have LIMIT */
3250 }
3251 }
3253 {
3258 double nrows;
3259
3260 /* Use rows/width estimates made by the core code. */
3261 rows = foreignrel->rows;
3263
3264 /* For join we expect inner and outer relations set */
3266
3269
3270 /* Estimate of number of rows in cross product */
3272
3273 /*
3274 * Back into an estimate of the number of retrieved rows. Just in
3275 * case this is nuts, clamp to at most nrows.
3276 */
3278 retrieved_rows = Min(retrieved_rows, nrows);
3279
3280 /*
3281 * The cost of foreign join is estimated as cost of generating
3282 * rows for the joining relations + cost for applying quals on the
3283 * rows.
3284 */
3285
3286 /*
3287 * Calculate the cost of clauses pushed down to the foreign server
3288 */
3290 /* Calculate the cost of applying join clauses */
3292
3293 /*
3294 * Startup cost includes startup cost of joining relations and the
3295 * startup cost for join and other clauses. We do not include the
3296 * startup cost specific to join strategy (e.g. setting up hash
3297 * tables) since we do not know what strategy the foreign server
3298 * is going to use.
3299 */
3301 startup_cost += join_cost.startup;
3302 startup_cost += remote_conds_cost.startup;
3303 startup_cost += fpinfo->local_conds_cost.startup;
3304
3305 /*
3306 * Run time cost includes:
3307 *
3308 * 1. Run time cost (total_cost - startup_cost) of relations being
3309 * joined
3310 *
3311 * 2. Run time cost of applying join clauses on the cross product
3312 * of the joining relations.
3313 *
3314 * 3. Run time cost of applying pushed down other clauses on the
3315 * result of join
3316 *
3317 * 4. Run time cost of applying nonpushable other clauses locally
3318 * on the result fetched from the foreign server.
3319 */
3322 run_cost += nrows * join_cost.per_tuple;
3324 run_cost += nrows * remote_conds_cost.per_tuple;
3325 run_cost += fpinfo->local_conds_cost.per_tuple * retrieved_rows;
3326
3327 /* Add in tlist eval cost for each output row */
3330 }
3332 {
3338 double numGroups = 1;
3339
3340 /* The upper relation should have its outer relation set */
3341 Assert(outerrel);
3342 /* and that outer relation should have its reltarget set */
3344
3345 /*
3346 * This cost model is mixture of costing done for sorted and
3347 * hashed aggregates in cost_agg(). We are not sure which
3348 * strategy will be considered at remote side, thus for
3349 * simplicity, we put all startup related costs in startup_cost
3350 * and all finalization and run cost are added in total_cost.
3351 */
3352
3354
3355 /* Get rows from input rel */
3357
3358 /* Collect statistics about aggregates for estimating costs. */
3360 {
3362 }
3363
3364 /* Get number of grouping columns and possible number of groups */
3368 fpinfo->grouped_tlist),
3370
3371 /*
3372 * Get the retrieved_rows and rows estimates. If there are HAVING
3373 * quals, account for their selectivity.
3374 */
3376 {
3377 /* Factor in the selectivity of the remotely-checked quals */
3378 retrieved_rows =
3379 clamp_row_est(numGroups *
3381 fpinfo->remote_conds,
3382 0,
3383 JOIN_INNER,
3384 NULL));
3385 /* Factor in the selectivity of the locally-checked quals */
3387 }
3388 else
3389 {
3390 rows = retrieved_rows = numGroups;
3391 }
3392
3393 /* Use width estimate made by the core code. */
3395
3396 /*-----
3397 * Startup cost includes:
3398 * 1. Startup cost for underneath input relation, adjusted for
3399 * tlist replacement by apply_scanjoin_target_to_paths()
3400 * 2. Cost of performing aggregation, per cost_agg()
3401 *-----
3402 */
3403 startup_cost = ofpinfo->rel_startup_cost;
3404 startup_cost += outerrel->reltarget->cost.startup;
3405 startup_cost += aggcosts.transCost.startup;
3407 startup_cost += aggcosts.finalCost.startup;
3409
3410 /*-----
3411 * Run time cost includes:
3412 * 1. Run time cost of underneath input relation, adjusted for
3413 * tlist replacement by apply_scanjoin_target_to_paths()
3414 * 2. Run time cost of performing aggregation, per cost_agg()
3415 *-----
3416 */
3418 run_cost += outerrel->reltarget->cost.per_tuple * input_rows;
3419 run_cost += aggcosts.finalCost.per_tuple * numGroups;
3420 run_cost += cpu_tuple_cost * numGroups;
3421
3422 /* Account for the eval cost of HAVING quals, if any */
3424 {
3426
3427 /* Add in the eval cost of the remotely-checked quals */
3429 startup_cost += remote_cost.startup;
3430 run_cost += remote_cost.per_tuple * numGroups;
3431 /* Add in the eval cost of the locally-checked quals */
3432 startup_cost += fpinfo->local_conds_cost.startup;
3433 run_cost += fpinfo->local_conds_cost.per_tuple * retrieved_rows;
3434 }
3435
3436 /* Add in tlist eval cost for each output row */
3439 }
3440 else
3441 {
3443
3444 /* Use rows/width estimates made by set_baserel_size_estimates. */
3445 rows = foreignrel->rows;
3447
3448 /*
3449 * Back into an estimate of the number of retrieved rows. Just in
3450 * case this is nuts, clamp to at most foreignrel->tuples.
3451 */
3454
3455 /*
3456 * Cost as though this were a seqscan, which is pessimistic. We
3457 * effectively imagine the local_conds are being evaluated
3458 * remotely, too.
3459 */
3460 startup_cost = 0;
3461 run_cost = 0;
3463
3467
3468 /* Add in tlist eval cost for each output row */
3471 }
3472
3473 /*
3474 * Without remote estimates, we have no real way to estimate the cost
3475 * of generating sorted output. It could be free if the query plan
3476 * the remote side would have chosen generates properly-sorted output
3477 * anyway, but in most cases it will cost something. Estimate a value
3478 * high enough that we won't pick the sorted path when the ordering
3479 * isn't locally useful, but low enough that we'll err on the side of
3480 * pushing down the ORDER BY clause when it's useful to do so.
3481 */
3483 {
3485 {
3488
3489 /*
3490 * We can only get here when this function is called from
3491 * add_foreign_ordered_paths() or add_foreign_final_paths();
3492 * in which cases, the passed-in fpextra should not be NULL.
3493 */
3496 retrieved_rows, width,
3497 fpextra->limit_tuples,
3498 &disabled_nodes,
3499 &startup_cost, &run_cost);
3500 }
3501 else
3502 {
3503 startup_cost *= DEFAULT_FDW_SORT_MULTIPLIER;
3504 run_cost *= DEFAULT_FDW_SORT_MULTIPLIER;
3505 }
3506 }
3507
3508 total_cost = startup_cost + run_cost;
3509
3510 /* Adjust the cost estimates if we have LIMIT */
3512 {
3513 adjust_limit_rows_costs(&rows, &startup_cost, &total_cost,
3515 retrieved_rows = rows;
3516 }
3517 }
3518
3519 /*
3520 * If this includes the final sort step, the given target, which will be
3521 * applied to the resulting path, might have different expressions from
3522 * the foreignrel's reltarget (see make_sort_input_target()); adjust tlist
3523 * eval costs.
3524 */
3527 {
3530
3534 }
3535
3536 /*
3537 * Cache the retrieved rows and cost estimates for scans, joins, or
3538 * groupings without any parameterization, pathkeys, or additional
3539 * post-scan/join-processing steps, before adding the costs for
3540 * transferring data from the foreign server. These estimates are useful
3541 * for costing remote joins involving this relation or costing other
3542 * remote operations on this relation such as remote sorts and remote
3543 * LIMIT restrictions, when the costs can not be obtained from the foreign
3544 * server. This function will be called at least once for every foreign
3545 * relation without any parameterization, pathkeys, or additional
3546 * post-scan/join-processing steps.
3547 */
3549 {
3550 fpinfo->retrieved_rows = retrieved_rows;
3551 fpinfo->rel_startup_cost = startup_cost;
3552 fpinfo->rel_total_cost = total_cost;
3553 }
3554
3555 /*
3556 * Add some additional cost factors to account for connection overhead
3557 * (fdw_startup_cost), transferring data across the network
3558 * (fdw_tuple_cost per retrieved row), and local manipulation of the data
3559 * (cpu_tuple_cost per retrieved row).
3560 */
3561 startup_cost += fpinfo->fdw_startup_cost;
3562 total_cost += fpinfo->fdw_startup_cost;
3563 total_cost += fpinfo->fdw_tuple_cost * retrieved_rows;
3564 total_cost += cpu_tuple_cost * retrieved_rows;
3565
3566 /*
3567 * If we have LIMIT, we should prefer performing the restriction remotely
3568 * rather than locally, as the former avoids extra row fetches from the
3569 * remote that the latter might cause. But since the core code doesn't
3570 * account for such fetches when estimating the costs of the local
3571 * restriction (see create_limit_path()), there would be no difference
3572 * between the costs of the local restriction and the costs of the remote
3573 * restriction estimated above if we don't use remote estimates (except
3574 * for the case where the foreignrel is a grouping relation, the given
3575 * pathkeys is not NIL, and the effects of a bounded sort for that rel is
3576 * accounted for in costing the remote restriction). Tweak the costs of
3577 * the remote restriction to ensure we'll prefer it if LIMIT is a useful
3578 * one.
3579 */
3582 fpextra->limit_tuples > 0 &&
3584 {
3586 total_cost -= (total_cost - startup_cost) * 0.05 *
3588 }
3589
3590 /* Return results. */
3591 *p_rows = rows;
3592 *p_width = width;
3593 *p_disabled_nodes = disabled_nodes;
3594 *p_startup_cost = startup_cost;
3595 *p_total_cost = total_cost;
3596}
void deparseSelectStmtForRel(StringInfo buf, PlannerInfo *root, RelOptInfo *rel, List *tlist, List *remote_conds, List *pathkeys, bool has_final_sort, bool has_limit, bool is_subquery, List **retrieved_attrs, List **params_list)
Definition deparse.c:1266
void classifyConditions(PlannerInfo *root, RelOptInfo *baserel, List *input_conds, List **remote_conds, List **local_conds)
Definition deparse.c:218
List * build_tlist_to_deparse(RelOptInfo *foreignrel)
Definition deparse.c:1209
void adjust_limit_rows_costs(double *rows, Cost *startup_cost, Cost *total_cost, int64 offset_est, int64 count_est)
Definition pathnode.c:3792
static void get_remote_estimate(const char *sql, PGconn *conn, double *rows, int *width, Cost *startup_cost, Cost *total_cost)
Definition postgres_fdw.c:3603
static void adjust_foreign_grouping_path_cost(PlannerInfo *root, List *pathkeys, double retrieved_rows, double width, double limit_tuples, int *p_disabled_nodes, Cost *p_startup_cost, Cost *p_run_cost)
Definition postgres_fdw.c:3640
void get_agg_clause_costs(PlannerInfo *root, AggSplit aggsplit, AggClauseCosts *costs)
Definition prepagg.c:559
double estimate_num_groups(PlannerInfo *root, List *groupExprs, double input_rows, List **pgset, EstimationInfo *estinfo)
Definition selfuncs.c:3771
void appendStringInfoString(StringInfo str, const char *s)
Definition stringinfo.c:230
Definition pathnodes.h:132
Definition pathnodes.h:119
Definition pathnodes.h:992
List * get_sortgrouplist_exprs(List *sgClauses, List *targetList)
Definition tlist.c:401
References adjust_foreign_grouping_path_cost(), adjust_limit_rows_costs(), AGGSPLIT_SIMPLE, appendStringInfoString(), Assert, RelOptInfo::baserestrictcost, build_tlist_to_deparse(), clamp_row_est(), classifyConditions(), clauselist_selectivity(), conn, PathTarget::cost, cost_qual_eval(), cpu_operator_cost, cpu_tuple_cost, StringInfoData::data, DEFAULT_FDW_SORT_MULTIPLIER, deparseSelectStmtForRel(), estimate_num_groups(), fb(), get_agg_clause_costs(), get_remote_estimate(), get_sortgrouplist_exprs(), GetConnection(), initStringInfo(), IS_JOIN_REL, IS_UPPER_REL, JOIN_INNER, list_concat(), list_length(), Min, NIL, RelOptInfo::pages, QualCost::per_tuple, ReleaseConnection(), RelOptInfo::relid, RELOPT_BASEREL, RELOPT_JOINREL, RELOPT_UPPER_REL, RelOptInfo::reloptkind, RelOptInfo::reltarget, root, RelOptInfo::rows, seq_page_cost, QualCost::startup, RelOptInfo::tuples, UPPERREL_GROUP_AGG, and PathTarget::width.
Referenced by add_foreign_final_paths(), add_foreign_grouping_paths(), add_foreign_ordered_paths(), add_paths_with_pathkeys_for_rel(), postgresGetForeignJoinPaths(), postgresGetForeignPaths(), and postgresGetForeignRelSize().
◆ execute_dml_stmt()
|
static |
Definition at line 4515 of file postgres_fdw.c.
4516{
4521
4522 /* First, process a pending asynchronous request, if any. */
4525
4526 /*
4527 * Construct array of query parameter values in text format.
4528 */
4529 if (numParams > 0)
4530 process_query_params(econtext,
4531 dmstate->param_flinfo,
4532 dmstate->param_exprs,
4533 values);
4534
4535 /*
4536 * Notice that we pass NULL for paramTypes, thus forcing the remote server
4537 * to infer types for all parameters. Since we explicitly cast every
4538 * parameter (see deparse.c), the "inference" is trivial and will produce
4539 * the desired result. This allows us to avoid assuming that the remote
4540 * server has the same OIDs we do for the parameters' types.
4541 */
4545
4546 /*
4547 * Get the result, and check for success.
4548 */
4553 dmstate->query);
4554
4555 /*
4556 * The result potentially needs to survive across multiple executor row
4557 * cycles, so move it to the context where the dmstate is.
4558 */
4561
4562 /* Get the number of rows affected. */
4565 else
4567}
static libpqsrv_PGresult * libpqsrv_PGresultSetParent(libpqsrv_PGresult *bres, MemoryContext ctx)
Definition libpq-be-fe.h:109
Definition postgres_fdw.c:221
References fb(), ForeignScanState::fdw_state, GetMemoryChunkContext(), libpqsrv_PGresultSetParent(), pgfdw_get_result(), pgfdw_report_error(), PGRES_COMMAND_OK, PGRES_TUPLES_OK, PQcmdTuples, PQntuples, PQresultStatus, PQsendQueryParams(), process_pending_request(), process_query_params(), ScanState::ps, PlanState::ps_ExprContext, ForeignScanState::ss, and values.
Referenced by postgresIterateDirectModify().
◆ execute_foreign_modify()
|
static |
Definition at line 4077 of file postgres_fdw.c.
4083{
4087 PGresult *res;
4089 StringInfoData sql;
4090
4091 /* The operation should be INSERT, UPDATE, or DELETE */
4093 operation == CMD_UPDATE ||
4094 operation == CMD_DELETE);
4095
4096 /* First, process a pending asynchronous request, if any. */
4099
4100 /*
4101 * If the existing query was deparsed and prepared for a different number
4102 * of rows, rebuild it for the proper number.
4103 */
4105 {
4106 /* Destroy the prepared statement created previously */
4109
4110 /* Build INSERT string with numSlots records in its VALUES clause. */
4111 initStringInfo(&sql);
4115 *numSlots - 1);
4119 }
4120
4121 /* Set up the prepared statement on the remote server, if we didn't yet */
4124
4125 /*
4126 * For UPDATE/DELETE, get the ctid that was passed up as a resjunk column
4127 */
4129 {
4130 Datum datum;
4131 bool isNull;
4132
4134 fmstate->ctidAttno,
4135 &isNull);
4136 /* shouldn't ever get a null result... */
4137 if (isNull)
4140 }
4141
4142 /* Convert parameters needed by prepared statement to text form */
4144
4145 /*
4146 * Execute the prepared statement.
4147 */
4149 fmstate->p_name,
4151 p_values,
4152 NULL,
4153 NULL,
4154 0))
4156
4157 /*
4158 * Get the result, and check for success.
4159 */
4164
4165 /* Check number of rows affected, and fetch RETURNING tuple if any */
4167 {
4172 }
4173 else
4175
4176 /* And clean up */
4177 PQclear(res);
4178
4180
4182
4183 /*
4184 * Return NULL if nothing was inserted/updated/deleted on the remote end
4185 */
4187}
void rebuildInsertSql(StringInfo buf, Relation rel, char *orig_query, List *target_attrs, int values_end_len, int num_params, int num_rows)
Definition deparse.c:2187
static Datum ExecGetJunkAttribute(TupleTableSlot *slot, AttrNumber attno, bool *isNull)
Definition executor.h:225
int PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, const char *const *paramValues, const int *paramLengths, const int *paramFormats, int resultFormat)
Definition fe-exec.c:1650
static const char ** convert_prep_stmt_params(PgFdwModifyState *fmstate, ItemPointer tupleid, TupleTableSlot **slots, int numSlots)
Definition postgres_fdw.c:4246
static void store_returning_result(PgFdwModifyState *fmstate, TupleTableSlot *slot, PGresult *res)
Definition postgres_fdw.c:4322
static void deallocate_query(PgFdwModifyState *fmstate)
Definition postgres_fdw.c:4364
static void prepare_foreign_modify(PgFdwModifyState *fmstate)
Definition postgres_fdw.c:4194
References Assert, CMD_DELETE, CMD_INSERT, CMD_UPDATE, convert_prep_stmt_params(), StringInfoData::data, DatumGetPointer(), deallocate_query(), elog, ERROR, ExecGetJunkAttribute(), fb(), initStringInfo(), MemoryContextReset(), pfree(), pgfdw_get_result(), pgfdw_report_error(), PGRES_COMMAND_OK, PGRES_TUPLES_OK, PQclear, PQcmdTuples, PQntuples, PQresultStatus, PQsendQueryPrepared(), prepare_foreign_modify(), process_pending_request(), rebuildInsertSql(), ResultRelInfo::ri_FdwState, and store_returning_result().
Referenced by postgresExecForeignBatchInsert(), postgresExecForeignDelete(), postgresExecForeignInsert(), and postgresExecForeignUpdate().
◆ fetch_more_data()
|
static |
Definition at line 3798 of file postgres_fdw.c.
3799{
3802 PGresult *res;
3803 int numrows;
3805 MemoryContext oldcontext;
3806
3807 /*
3808 * We'll store the tuples in the batch_cxt. First, flush the previous
3809 * batch.
3810 */
3811 fsstate->tuples = NULL;
3812 MemoryContextReset(fsstate->batch_cxt);
3813 oldcontext = MemoryContextSwitchTo(fsstate->batch_cxt);
3814
3815 if (fsstate->async_capable)
3816 {
3817 Assert(fsstate->conn_state->pendingAreq);
3818
3819 /*
3820 * The query was already sent by an earlier call to
3821 * fetch_more_data_begin. So now we just fetch the result.
3822 */
3824 /* On error, report the original query, not the FETCH. */
3827
3828 /* Reset per-connection state */
3829 fsstate->conn_state->pendingAreq = NULL;
3830 }
3831 else
3832 {
3833 char sql[64];
3834
3835 /* This is a regular synchronous fetch. */
3837 fsstate->fetch_size, fsstate->cursor_number);
3838
3840 /* On error, report the original query, not the FETCH. */
3843 }
3844
3845 /* Convert the data into HeapTuples */
3846 numrows = PQntuples(res);
3848 fsstate->num_tuples = numrows;
3849 fsstate->next_tuple = 0;
3850
3852 {
3854
3855 fsstate->tuples[i] =
3857 fsstate->rel,
3858 fsstate->attinmeta,
3859 fsstate->retrieved_attrs,
3860 node,
3861 fsstate->temp_cxt);
3862 }
3863
3864 /* Update fetch_ct_2 */
3865 if (fsstate->fetch_ct_2 < 2)
3866 fsstate->fetch_ct_2++;
3867
3868 /* Must be EOF if we didn't get as many tuples as we asked for. */
3869 fsstate->eof_reached = (numrows < fsstate->fetch_size);
3870
3871 PQclear(res);
3872
3873 MemoryContextSwitchTo(oldcontext);
3874}
References Assert, PgFdwScanState::async_capable, PgFdwScanState::attinmeta, PgFdwScanState::batch_cxt, PgFdwScanState::conn, conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_number, PgFdwScanState::eof_reached, fb(), ForeignScanState::fdw_state, PgFdwScanState::fetch_ct_2, PgFdwScanState::fetch_size, i, IsA, make_tuple_from_result_row(), MemoryContextReset(), MemoryContextSwitchTo(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, palloc0(), PgFdwConnState::pendingAreq, pgfdw_exec_query(), pgfdw_get_result(), pgfdw_report_error(), PGRES_TUPLES_OK, PlanState::plan, PQclear, PQntuples, PQresultStatus, ScanState::ps, PgFdwScanState::query, PgFdwScanState::rel, PgFdwScanState::retrieved_attrs, snprintf, ForeignScanState::ss, PgFdwScanState::temp_cxt, and PgFdwScanState::tuples.
Referenced by postgresForeignAsyncNotify(), postgresIterateForeignScan(), postgresReScanForeignScan(), and process_pending_request().
◆ fetch_more_data_begin()
|
static |
Definition at line 7397 of file postgres_fdw.c.
7398{
7401 char sql[64];
7402
7404
7405 /* Create the cursor synchronously. */
7407 create_cursor(node);
7408
7409 /* We will send this query, but not wait for the response. */
7412
7415
7416 /* Remember that the request is in process */
7418}
References Assert, PgFdwScanState::conn, PgFdwScanState::conn_state, create_cursor(), PgFdwScanState::cursor_exists, PgFdwScanState::cursor_number, fb(), ForeignScanState::fdw_state, PgFdwScanState::fetch_size, PgFdwConnState::pendingAreq, pgfdw_report_error(), PQsendQuery(), PgFdwScanState::query, and snprintf.
Referenced by postgresForeignAsyncConfigureWait(), and produce_tuple_asynchronously().
◆ find_em_for_rel()
| EquivalenceMember * find_em_for_rel | ( | PlannerInfo * | root, |
| EquivalenceClass * | ec, | ||
| RelOptInfo * | rel | ||
| ) |
Definition at line 7751 of file postgres_fdw.c.
7752{
7756
7759 {
7760 /*
7761 * Note we require !bms_is_empty, else we'd accept constant
7762 * expressions which are not suitable for the purpose.
7763 */
7769 }
7770
7772}
Bitmapset * bms_intersect(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:292
void setup_eclass_member_iterator(EquivalenceMemberIterator *it, EquivalenceClass *ec, Relids child_relids)
Definition equivclass.c:3155
EquivalenceMember * eclass_member_iterator_next(EquivalenceMemberIterator *it)
Definition equivclass.c:3174
Definition pathnodes.h:1760
Definition pathnodes.h:1695
References bms_intersect(), bms_is_empty, bms_is_subset(), eclass_member_iterator_next(), fb(), is_foreign_expr(), RelOptInfo::relids, root, and setup_eclass_member_iterator().
Referenced by appendOrderByClause(), get_useful_pathkeys_for_relation(), and is_foreign_pathkey().
◆ find_em_for_rel_target()
| EquivalenceMember * find_em_for_rel_target | ( | PlannerInfo * | root, |
| EquivalenceClass * | ec, | ||
| RelOptInfo * | rel | ||
| ) |
Definition at line 7786 of file postgres_fdw.c.
7788{
7792
7793 i = 0;
7795 {
7799
7800 /* Ignore non-sort expressions */
7804 {
7805 i++;
7806 continue;
7807 }
7808
7809 /* We ignore binary-compatible relabeling on both ends */
7811 expr = ((RelabelType *) expr)->arg;
7812
7813 /*
7814 * Locate an EquivalenceClass member matching this expr, if any.
7815 * Ignore child members.
7816 */
7818 {
7820 Expr *em_expr;
7821
7822 /* Don't match constants */
7824 continue;
7825
7826 /* Child members should not exist in ec_members */
7828
7829 /* Match if same expression (after stripping relabel) */
7830 em_expr = em->em_expr;
7832 em_expr = ((RelabelType *) em_expr)->arg;
7833
7835 continue;
7836
7837 /* Check that expression (including relabels!) is shippable */
7840 }
7841
7842 i++;
7843 }
7844
7846}
#define get_pathtarget_sortgroupref(target, colno)
Definition pathnodes.h:1874
Definition primnodes.h:1215
SortGroupClause * get_sortgroupref_clause_noerr(Index sortref, List *clauses)
Definition tlist.c:452
References Assert, EquivalenceClass::ec_members, equal(), PathTarget::exprs, fb(), get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), i, is_foreign_expr(), IsA, lfirst, RelOptInfo::reltarget, and root.
Referenced by add_foreign_ordered_paths(), and appendOrderByClause().
◆ find_modifytable_subplan()
|
static |
Definition at line 2388 of file postgres_fdw.c.
2392{
2394
2395 /*
2396 * The cases we support are (1) the desired ForeignScan is the immediate
2397 * child of ModifyTable, or (2) it is the subplan_index'th child of an
2398 * Append node that is the immediate child of ModifyTable. There is no
2399 * point in looking further down, as that would mean that local joins are
2400 * involved, so we can't do the update directly.
2401 *
2402 * There could be a Result atop the Append too, acting to compute the
2403 * UPDATE targetlist values. We ignore that here; the tlist will be
2404 * checked by our caller.
2405 *
2406 * In principle we could examine all the children of the Append, but it's
2407 * currently unlikely that the core planner would generate such a plan
2408 * with the children out-of-order. Moreover, such a search risks costing
2409 * O(N^2) time when there are a lot of children.
2410 */
2412 {
2414
2417 }
2421 {
2423
2426 }
2427
2428 /* Now, have we got a ForeignScan on the desired rel? */
2430 {
2432
2435 }
2436
2438}
Definition plannodes.h:389
Definition plannodes.h:186
Definition plannodes.h:296
References bms_is_member(), fb(), IsA, list_length(), list_nth(), outerPlan, and plan.
Referenced by postgresPlanDirectModify().
◆ finish_foreign_modify()
|
static |
Definition at line 4346 of file postgres_fdw.c.
4347{
4349
4350 /* If we created a prepared statement, destroy it */
4352
4353 /* Release remote connection */
4356}
References Assert, deallocate_query(), fb(), and ReleaseConnection().
Referenced by postgresEndForeignInsert(), and postgresEndForeignModify().
◆ foreign_grouping_ok()
|
static |
Definition at line 6408 of file postgres_fdw.c.
6410{
6418
6419 /* We currently don't support pushing Grouping Sets. */
6420 if (query->groupingSets)
6421 return false;
6422
6423 /* Get the fpinfo of the underlying scan relation. */
6425
6426 /*
6427 * If underlying scan relation has any local conditions, those conditions
6428 * are required to be applied before performing aggregation. Hence the
6429 * aggregate cannot be pushed down.
6430 */
6432 return false;
6433
6434 /*
6435 * Examine grouping expressions, as well as other expressions we'd need to
6436 * compute, and check whether they are safe to push down to the foreign
6437 * server. All GROUP BY expressions will be part of the grouping target
6438 * and thus there is no need to search for them separately. Add grouping
6439 * expressions into target list which will be passed to foreign server.
6440 *
6441 * A tricky fine point is that we must not put any expression into the
6442 * target list that is just a foreign param (that is, something that
6443 * deparse.c would conclude has to be sent to the foreign server). If we
6444 * do, the expression will also appear in the fdw_exprs list of the plan
6445 * node, and setrefs.c will get confused and decide that the fdw_exprs
6446 * entry is actually a reference to the fdw_scan_tlist entry, resulting in
6447 * a broken plan. Somewhat oddly, it's OK if the expression contains such
6448 * a node, as long as it's not at top level; then no match is possible.
6449 */
6450 i = 0;
6452 {
6455 ListCell *l;
6456
6457 /*
6458 * Check whether this expression is part of GROUP BY clause. Note we
6459 * check the whole GROUP BY clause not just processed_groupClause,
6460 * because we will ship all of it, cf. appendGroupByClause.
6461 */
6463 {
6465
6466 /*
6467 * If any GROUP BY expression is not shippable, then we cannot
6468 * push down aggregation to the foreign server.
6469 */
6471 return false;
6472
6473 /*
6474 * If it would be a foreign param, we can't put it into the tlist,
6475 * so we have to fail.
6476 */
6478 return false;
6479
6480 /*
6481 * Pushable, so add to tlist. We need to create a TLE for this
6482 * expression and apply the sortgroupref to it. We cannot use
6483 * add_to_flat_tlist() here because that avoids making duplicate
6484 * entries in the tlist. If there are duplicate entries with
6485 * distinct sortgrouprefs, we have to duplicate that situation in
6486 * the output tlist.
6487 */
6491 }
6492 else
6493 {
6494 /*
6495 * Non-grouping expression we need to compute. Can we ship it
6496 * as-is to the foreign server?
6497 */
6500 {
6501 /* Yes, so add to tlist as-is; OK to suppress duplicates */
6503 }
6504 else
6505 {
6506 /* Not pushable as a whole; extract its Vars and aggregates */
6508
6510 PVC_INCLUDE_AGGREGATES);
6511
6512 /*
6513 * If any aggregate expression is not shippable, then we
6514 * cannot push down aggregation to the foreign server. (We
6515 * don't have to check is_foreign_param, since that certainly
6516 * won't return true for any such expression.)
6517 */
6519 return false;
6520
6521 /*
6522 * Add aggregates, if any, into the targetlist. Plain Vars
6523 * outside an aggregate can be ignored, because they should be
6524 * either same as some GROUP BY column or part of some GROUP
6525 * BY expression. In either case, they are already part of
6526 * the targetlist and thus no need to add them again. In fact
6527 * including plain Vars in the tlist when they do not match a
6528 * GROUP BY column would cause the foreign server to complain
6529 * that the shipped query is invalid.
6530 */
6532 {
6534
6537 }
6538 }
6539 }
6540
6541 i++;
6542 }
6543
6544 /*
6545 * Classify the pushable and non-pushable HAVING clauses and save them in
6546 * remote_conds and local_conds of the grouped rel's fpinfo.
6547 */
6548 if (havingQual)
6549 {
6551 {
6553 RestrictInfo *rinfo;
6554
6555 /*
6556 * Currently, the core code doesn't wrap havingQuals in
6557 * RestrictInfos, so we must make our own.
6558 */
6561 expr,
6562 true,
6563 false,
6564 false,
6565 false,
6566 root->qual_security_level,
6567 grouped_rel->relids,
6568 NULL,
6569 NULL);
6572 else
6574 }
6575 }
6576
6577 /*
6578 * If there are any local conditions, pull Vars and aggregates from it and
6579 * check whether they are safe to pushdown or not.
6580 */
6582 {
6584
6586 {
6588
6591 PVC_INCLUDE_AGGREGATES));
6592 }
6593
6595 {
6597
6598 /*
6599 * If aggregates within local conditions are not safe to push
6600 * down, then we cannot push down the query. Vars are already
6601 * part of GROUP BY clause which are checked above, so no need to
6602 * access them again here. Again, we need not check
6603 * is_foreign_param for a foreign aggregate.
6604 */
6606 {
6608 return false;
6609
6611 }
6612 }
6613 }
6614
6615 /* Store generated targetlist */
6616 fpinfo->grouped_tlist = tlist;
6617
6618 /* Safe to pushdown */
6620
6621 /*
6622 * Set # of retrieved rows and cached relation costs to some negative
6623 * value, so that we can detect when they are set to some sensible values,
6624 * during one (usually the first) of the calls to estimate_path_cost_size.
6625 */
6626 fpinfo->retrieved_rows = -1;
6627 fpinfo->rel_startup_cost = -1;
6628 fpinfo->rel_total_cost = -1;
6629
6630 /*
6631 * Set the string describing this grouped relation to be used in EXPLAIN
6632 * output of corresponding ForeignScan. Note that the decoration we add
6633 * to the base relation name mustn't include any digits, or it'll confuse
6634 * postgresExplainForeignScan.
6635 */
6637 ofpinfo->relation_name);
6638
6639 return true;
6640}
bool is_foreign_param(PlannerInfo *root, RelOptInfo *baserel, Expr *expr)
Definition deparse.c:1115
RestrictInfo * make_restrictinfo(PlannerInfo *root, Expr *clause, bool is_pushed_down, bool has_clone, bool is_clone, bool pseudoconstant, Index security_level, Relids required_relids, Relids incompatible_relids, Relids outer_relids)
Definition restrictinfo.c:52
Definition primnodes.h:459
References add_to_flat_tlist(), Assert, RestrictInfo::clause, fb(), get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), Query::groupClause, Query::groupingSets, i, is_foreign_expr(), is_foreign_param(), IsA, lappend(), lfirst, lfirst_node, list_concat(), list_length(), list_make1, make_restrictinfo(), makeTargetEntry(), NIL, psprintf(), pull_var_clause(), PVC_INCLUDE_AGGREGATES, RelOptInfo::relids, RelOptInfo::reltarget, and root.
Referenced by add_foreign_grouping_paths().
◆ foreign_join_ok()
|
static |
Definition at line 5699 of file postgres_fdw.c.
5702{
5707 List *joinclauses;
5708
5709 /*
5710 * We support pushing down INNER, LEFT, RIGHT, FULL OUTER and SEMI joins.
5711 * Constructing queries representing ANTI joins is hard, hence not
5712 * considered right now.
5713 */
5716 jointype != JOIN_SEMI)
5717 return false;
5718
5719 /*
5720 * We can't push down semi-join if its reltarget is not safe
5721 */
5723 return false;
5724
5725 /*
5726 * If either of the joining relations is marked as unsafe to pushdown, the
5727 * join can not be pushed down.
5728 */
5734 return false;
5735
5736 /*
5737 * If joining relations have local conditions, those conditions are
5738 * required to be applied before joining the relations. Hence the join can
5739 * not be pushed down.
5740 */
5742 return false;
5743
5744 /*
5745 * Merge FDW options. We might be tempted to do this after we have deemed
5746 * the foreign join to be OK. But we must do this beforehand so that we
5747 * know which quals can be evaluated on the foreign server, which might
5748 * depend on shippable_extensions.
5749 */
5752
5753 /*
5754 * Separate restrict list into join quals and pushed-down (other) quals.
5755 *
5756 * Join quals belonging to an outer join must all be shippable, else we
5757 * cannot execute the join remotely. Add such quals to 'joinclauses'.
5758 *
5759 * Add other quals to fpinfo->remote_conds if they are shippable, else to
5760 * fpinfo->local_conds. In an inner join it's okay to execute conditions
5761 * either locally or remotely; the same is true for pushed-down conditions
5762 * at an outer join.
5763 *
5764 * Note we might return failure after having already scribbled on
5765 * fpinfo->remote_conds and fpinfo->local_conds. That's okay because we
5766 * won't consult those lists again if we deem the join unshippable.
5767 */
5768 joinclauses = NIL;
5770 {
5773 rinfo->clause);
5774
5777 {
5779 return false;
5780 joinclauses = lappend(joinclauses, rinfo);
5781 }
5782 else
5783 {
5786 else
5788 }
5789 }
5790
5791 /*
5792 * deparseExplicitTargetList() isn't smart enough to handle anything other
5793 * than a Var. In particular, if there's some PlaceHolderVar that would
5794 * need to be evaluated within this join tree (because there's an upper
5795 * reference to a quantity that may go to NULL as a result of an outer
5796 * join), then we can't try to push the join down because we'll fail when
5797 * we get to deparseExplicitTargetList(). However, a PlaceHolderVar that
5798 * needs to be evaluated *at the top* of this join tree is OK, because we
5799 * can do that locally after fetching the results from the remote side.
5800 */
5802 {
5804 Relids relids;
5805
5806 /* PlaceHolderInfo refers to parent relids, not child relids. */
5807 relids = IS_OTHER_REL(joinrel) ?
5809
5812 return false;
5813 }
5814
5815 /* Save the join clauses, for later use. */
5816 fpinfo->joinclauses = joinclauses;
5817
5818 fpinfo->outerrel = outerrel;
5819 fpinfo->innerrel = innerrel;
5820 fpinfo->jointype = jointype;
5821
5822 /*
5823 * By default, both the input relations are not required to be deparsed as
5824 * subqueries, but there might be some relations covered by the input
5825 * relations that are required to be deparsed as subqueries, so save the
5826 * relids of those relations for later use by the deparser.
5827 */
5833 fpinfo_i->lower_subquery_rels);
5835 fpinfo_i->hidden_subquery_rels);
5836
5837 /*
5838 * Pull the other remote conditions from the joining relations into join
5839 * clauses or other remote clauses (remote_conds) of this relation
5840 * wherever possible. This avoids building subqueries at every join step.
5841 *
5842 * For an inner join, clauses from both the relations are added to the
5843 * other remote clauses. For LEFT and RIGHT OUTER join, the clauses from
5844 * the outer side are added to remote_conds since those can be evaluated
5845 * after the join is evaluated. The clauses from inner side are added to
5846 * the joinclauses, since they need to be evaluated while constructing the
5847 * join.
5848 *
5849 * For SEMI-JOIN clauses from inner relation can not be added to
5850 * remote_conds, but should be treated as join clauses (as they are
5851 * deparsed to EXISTS subquery, where inner relation can be referred). A
5852 * list of relation ids, which can't be referred to from higher levels, is
5853 * preserved as a hidden_subquery_rels list.
5854 *
5855 * For a FULL OUTER JOIN, the other clauses from either relation can not
5856 * be added to the joinclauses or remote_conds, since each relation acts
5857 * as an outer relation for the other.
5858 *
5859 * The joining sides can not have local conditions, thus no need to test
5860 * shippability of the clauses being pulled up.
5861 */
5862 switch (jointype)
5863 {
5866 fpinfo_i->remote_conds);
5868 fpinfo_o->remote_conds);
5869 break;
5870
5872
5873 /*
5874 * When semi-join is involved in the inner or outer part of the
5875 * left join, it's deparsed as a subquery, and we can't refer to
5876 * its vars on the upper level.
5877 */
5880 fpinfo_i->remote_conds);
5883 fpinfo_o->remote_conds);
5884 break;
5885
5887
5888 /*
5889 * When semi-join is involved in the inner or outer part of the
5890 * right join, it's deparsed as a subquery, and we can't refer to
5891 * its vars on the upper level.
5892 */
5895 fpinfo_o->remote_conds);
5898 fpinfo_i->remote_conds);
5899 break;
5900
5903 fpinfo_i->remote_conds);
5905 fpinfo->remote_conds);
5908 innerrel->relids);
5909 break;
5910
5912
5913 /*
5914 * In this case, if any of the input relations has conditions, we
5915 * need to deparse that relation as a subquery so that the
5916 * conditions can be evaluated before the join. Remember it in
5917 * the fpinfo of this relation so that the deparser can take
5918 * appropriate action. Also, save the relids of base relations
5919 * covered by that relation for later use by the deparser.
5920 */
5922 {
5924 fpinfo->lower_subquery_rels =
5926 outerrel->relids);
5927 }
5929 {
5931 fpinfo->lower_subquery_rels =
5933 innerrel->relids);
5934 }
5935 break;
5936
5937 default:
5938 /* Should not happen, we have just checked this above */
5940 }
5941
5942 /*
5943 * For an inner join, all restrictions can be treated alike. Treating the
5944 * pushed down conditions as join conditions allows a top level full outer
5945 * join to be deparsed without requiring subqueries.
5946 */
5948 {
5952 }
5954 {
5955 /*
5956 * Conditions, generated from semi-joins, should be evaluated before
5957 * LEFT/RIGHT/FULL join.
5958 */
5960 {
5963 }
5964
5966 {
5969 }
5970 }
5971
5972 /* Mark that this join can be pushed down safely */
5974
5975 /* Get user mapping */
5977 {
5980 else
5982 }
5983 else
5985
5986 /*
5987 * Set # of retrieved rows and cached relation costs to some negative
5988 * value, so that we can detect when they are set to some sensible values,
5989 * during one (usually the first) of the calls to estimate_path_cost_size.
5990 */
5991 fpinfo->retrieved_rows = -1;
5992 fpinfo->rel_startup_cost = -1;
5993 fpinfo->rel_total_cost = -1;
5994
5995 /*
5996 * Set the string describing this join relation to be used in EXPLAIN
5997 * output of corresponding ForeignScan. Note that the decoration we add
5998 * to the base relation names mustn't include any digits, or it'll confuse
5999 * postgresExplainForeignScan.
6000 */
6002 fpinfo_o->relation_name,
6004 fpinfo_i->relation_name);
6005
6006 /*
6007 * Set the relation index. This is defined as the position of this
6008 * joinrel in the join_rel_list list plus the length of the rtable list.
6009 * Note that since this joinrel is at the end of the join_rel_list list
6010 * when we are called, we can get the position by list_length.
6011 */
6013 fpinfo->relation_index =
6015
6016 return true;
6017}
Bitmapset * bms_add_members(Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:916
bool bms_nonempty_difference(const Bitmapset *a, const Bitmapset *b)
Definition bitmapset.c:640
static bool semijoin_target_ok(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel)
Definition postgres_fdw.c:5660
Definition bitmapset.h:50
Definition pathnodes.h:3374
References Assert, bms_add_members(), bms_is_empty, bms_is_subset(), bms_nonempty_difference(), bms_union(), RestrictInfo::clause, elog, ERROR, fb(), get_jointype_name(), is_foreign_expr(), IS_OTHER_REL, IS_OUTER_JOIN, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, JOIN_SEMI, lappend(), lfirst, lfirst_node, list_concat(), list_copy(), list_length(), merge_fdw_options(), NIL, psprintf(), RelOptInfo::relids, JoinPathExtraData::restrictlist, RINFO_IS_PUSHED_DOWN, root, semijoin_target_ok(), and RelOptInfo::top_parent_relids.
Referenced by postgresGetForeignJoinPaths().
◆ get_batch_size_option()
Definition at line 7853 of file postgres_fdw.c.
7854{
7857 ForeignServer *server;
7860
7861 /* we use 1 by default, which means "no batching" */
7862 int batch_size = 1;
7863
7864 /*
7865 * Load options for table and server. We append server options after table
7866 * options, because table options take precedence.
7867 */
7870
7874
7875 /* See if either table or server specifies batch_size. */
7877 {
7879
7881 {
7883 break;
7884 }
7885 }
7886
7887 return batch_size;
7888}
Definition foreign.h:35
Definition oid2name.c:30
References defGetString(), DefElem::defname, fb(), GetForeignServer(), GetForeignTable(), lfirst, list_concat(), NIL, ForeignServer::options, parse_int(), RelationGetRelid, and table.
Referenced by create_foreign_modify(), and postgresGetForeignModifyBatchSize().
◆ get_remote_estimate()
|
static |
Definition at line 3603 of file postgres_fdw.c.
3606{
3607 PGresult *res;
3608 char *line;
3609 char *p;
3610 int n;
3611
3612 /*
3613 * Execute EXPLAIN remotely.
3614 */
3618
3619 /*
3620 * Extract cost numbers for topmost plan node. Note we search for a left
3621 * paren from the end of the line to avoid being confused by other uses of
3622 * parentheses.
3623 */
3624 line = PQgetvalue(res, 0, 0);
3629 startup_cost, total_cost, rows, width);
3630 if (n != 4)
3632 PQclear(res);
3633}
References conn, elog, ERROR, fb(), pgfdw_exec_query(), pgfdw_report_error(), PGRES_TUPLES_OK, PQclear, PQgetvalue, and PQresultStatus.
Referenced by estimate_path_cost_size().
◆ get_returning_data()
|
static |
Definition at line 4573 of file postgres_fdw.c.
4574{
4580
4582
4583 /* If we didn't get any tuples, must be end of data. */
4586
4587 /* Increment the command es_processed count if necessary. */
4589 estate->es_processed += 1;
4590
4591 /*
4592 * Store a RETURNING tuple. If has_returning is false, just emit a dummy
4593 * tuple. (has_returning is false when the local query is of the form
4594 * "UPDATE/DELETE .. RETURNING 1" for example.)
4595 */
4597 {
4598 ExecStoreAllNullTuple(slot);
4599 resultSlot = slot;
4600 }
4601 else
4602 {
4604
4606 dmstate->next_tuple,
4607 dmstate->rel,
4608 dmstate->attinmeta,
4609 dmstate->retrieved_attrs,
4610 node,
4611 dmstate->temp_cxt);
4613 /* Get the updated/deleted tuple. */
4615 resultSlot = slot;
4616 else
4618 }
4619 dmstate->next_tuple++;
4620
4621 /* Make slot available for evaluation of the local query RETURNING list. */
4623 resultSlot;
4624
4625 return slot;
4626}
TupleTableSlot * ExecStoreAllNullTuple(TupleTableSlot *slot)
Definition execTuples.c:1765
TupleTableSlot * ExecStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition execTuples.c:1541
static TupleTableSlot * apply_returning_filter(PgFdwDirectModifyState *dmstate, ResultRelInfo *resultRelInfo, TupleTableSlot *slot, EState *estate)
Definition postgres_fdw.c:4705
Definition execnodes.h:475
References apply_returning_filter(), Assert, ExprContext::ecxt_scantuple, EState::es_processed, ExecClearTuple(), ExecStoreAllNullTuple(), ExecStoreHeapTuple(), fb(), ForeignScanState::fdw_state, make_tuple_from_result_row(), ProjectionInfo::pi_exprContext, ScanState::ps, ForeignScanState::resultRelInfo, ResultRelInfo::ri_projectReturning, ForeignScanState::ss, ScanState::ss_ScanTupleSlot, and PlanState::state.
Referenced by postgresIterateDirectModify().
◆ get_tupdesc_for_join_scan_tuples()
|
static |
Definition at line 1447 of file postgres_fdw.c.
1448{
1451 TupleDesc tupdesc;
1452
1453 /*
1454 * The core code has already set up a scan tuple slot based on
1455 * fsplan->fdw_scan_tlist, and this slot's tupdesc is mostly good enough,
1456 * but there's one case where it isn't. If we have any whole-row row
1457 * identifier Vars, they may have vartype RECORD, and we need to replace
1458 * that with the associated table's actual composite type. This ensures
1459 * that when we read those ROW() expression values from the remote server,
1460 * we can convert them to a composite type the local server knows.
1461 */
1464 {
1466 Var *var;
1468 Oid reltype;
1469
1470 /* Nothing to do if it's not a generic RECORD attribute */
1472 continue;
1473
1474 /*
1475 * If we can't identify the referenced table, do nothing. This'll
1476 * likely lead to failure later, but perhaps we can muddle through.
1477 */
1479 i)->expr;
1481 continue;
1484 continue;
1487 continue;
1488 att->atttypid = reltype;
1489 /* shouldn't need to change anything else */
1490 }
1491 return tupdesc;
1492}
References CreateTupleDescCopy(), EState::es_range_table, fb(), get_rel_type_id(), i, IsA, list_nth(), list_nth_node, TupleDescData::natts, OidIsValid, PlanState::plan, ScanState::ps, RTE_RELATION, ForeignScanState::ss, ScanState::ss_ScanTupleSlot, PlanState::state, TupleTableSlot::tts_tupleDescriptor, TupleDescAttr(), Var::varattno, and Var::varno.
Referenced by postgresBeginDirectModify(), and postgresBeginForeignScan().
◆ get_useful_ecs_for_relation()
|
static |
Definition at line 813 of file postgres_fdw.c.
814{
817 Relids relids;
818
819 /*
820 * First, consider whether any active EC is potentially useful for a merge
821 * join against this relation.
822 */
824 {
826 {
828
831 }
832 }
833
834 /*
835 * Next, consider whether there are any non-EC derivable join clauses that
836 * are merge-joinable. If the joininfo list is empty, we can exit
837 * quickly.
838 */
841
842 /* If this is a child rel, we must use the topmost parent rel to search. */
844 {
846 relids = rel->top_parent_relids;
847 }
848 else
849 relids = rel->relids;
850
851 /* Check each join clause in turn. */
853 {
855
856 /* Consider only mergejoinable clauses */
858 continue;
859
860 /* Make sure we've got canonical ECs. */
862
863 /*
864 * restrictinfo->mergeopfamilies != NIL is sufficient to guarantee
865 * that left_ec and right_ec will be initialized, per comments in
866 * distribute_qual_to_rels.
867 *
868 * We want to identify which side of this merge-joinable clause
869 * contains columns from the relation produced by this RelOptInfo. We
870 * test for overlap, not containment, because there could be extra
871 * relations on either side. For example, suppose we've got something
872 * like ((A JOIN B ON A.x = B.x) JOIN C ON A.y = C.y) LEFT JOIN D ON
873 * A.y = D.y. The input rel might be the joinrel between A and B, and
874 * we'll consider the join clause A.y = D.y. relids contains a
875 * relation not involved in the join class (B) and the equivalence
876 * class for the left-hand side of the clause contains a relation not
877 * involved in the input rel (C). Despite the fact that we have only
878 * overlap and not containment in either direction, A.y is potentially
879 * useful as a sort column.
880 *
881 * Note that it's even possible that relids overlaps neither side of
882 * the join clause. For example, consider A LEFT JOIN B ON A.x = B.x
883 * AND A.x = 1. The clause A.x = 1 will appear in B's joininfo list,
884 * but overlaps neither side of B. In that case, we just skip this
885 * join clause, since it doesn't suggest a useful sort order for this
886 * relation.
887 */
890 restrictinfo->right_ec);
893 restrictinfo->left_ec);
894 }
895
897}
bool eclass_useful_for_merging(PlannerInfo *root, EquivalenceClass *eclass, RelOptInfo *rel)
Definition equivclass.c:3489
void update_mergeclause_eclasses(PlannerInfo *root, RestrictInfo *restrictinfo)
Definition pathkeys.c:1510
References Assert, bms_is_empty, bms_overlap(), eclass_useful_for_merging(), fb(), RelOptInfo::has_eclass_joins, IS_OTHER_REL, RelOptInfo::joininfo, lappend(), lfirst, list_append_unique_ptr(), NIL, RelOptInfo::relids, root, RelOptInfo::top_parent_relids, and update_mergeclause_eclasses().
Referenced by get_useful_pathkeys_for_relation().
◆ get_useful_pathkeys_for_relation()
|
static |
Definition at line 909 of file postgres_fdw.c.
910{
916
917 /*
918 * Pushing the query_pathkeys to the remote server is always worth
919 * considering, because it might let us avoid a local sort.
920 */
923 {
925
927 {
929
930 /*
931 * The planner and executor don't have any clever strategy for
932 * taking data sorted by a prefix of the query's pathkeys and
933 * getting it to be sorted by all of those pathkeys. We'll just
934 * end up resorting the entire data set. So, unless we can push
935 * down all of the query pathkeys, forget it.
936 */
938 {
940 break;
941 }
942 }
943
945 {
948 }
949 }
950
951 /*
952 * Even if we're not using remote estimates, having the remote side do the
953 * sort generally won't be any worse than doing it locally, and it might
954 * be much better if the remote side can generate data in the right order
955 * without needing a sort at all. However, what we're going to do next is
956 * try to generate pathkeys that seem promising for possible merge joins,
957 * and that's more speculative. A wrong choice might hurt quite a bit, so
958 * bail out if we can't use remote estimates.
959 */
962
963 /* Get the list of interesting EquivalenceClasses. */
965
966 /* Extract unique EC for query, if any, so we don't consider it again. */
968 {
970
972 }
973
974 /*
975 * As a heuristic, the only pathkeys we consider here are those of length
976 * one. It's surely possible to consider more, but since each one we
977 * choose to consider will generate a round-trip to the remote side, we
978 * need to be a bit cautious here. It would sure be nice to have a local
979 * cache of information about remote index definitions...
980 */
982 {
985
986 /* If redundant with what we did above, skip it. */
988 continue;
989
990 /* Can't push down the sort if the EC's opfamily is not shippable. */
993 continue;
994
995 /* If no pushable expression for this rel, skip it. */
997 continue;
998
999 /* Looks like we can generate a pathkey, so let's do it. */
1002 COMPARE_LT,
1003 false);
1006 }
1007
1009}
bool is_foreign_pathkey(PlannerInfo *root, RelOptInfo *baserel, PathKey *pathkey)
Definition deparse.c:1156
PathKey * make_canonical_pathkey(PlannerInfo *root, EquivalenceClass *eclass, Oid opfamily, CompareType cmptype, bool nulls_first)
Definition pathkeys.c:56
EquivalenceMember * find_em_for_rel(PlannerInfo *root, EquivalenceClass *ec, RelOptInfo *rel)
Definition postgres_fdw.c:7751
static List * get_useful_ecs_for_relation(PlannerInfo *root, RelOptInfo *rel)
Definition postgres_fdw.c:813
References COMPARE_LT, fb(), find_em_for_rel(), get_useful_ecs_for_relation(), is_foreign_pathkey(), is_shippable(), lappend(), lfirst, linitial, linitial_oid, list_copy(), list_length(), list_make1, make_canonical_pathkey(), NIL, and root.
Referenced by add_paths_with_pathkeys_for_rel().
◆ init_returning_filter()
|
static |
Definition at line 4632 of file postgres_fdw.c.
4635{
4639
4640 /*
4641 * Calculate the mapping between the fdw_scan_tlist's entries and the
4642 * result tuple's attributes.
4643 *
4644 * The "map" is an array of indexes of the result tuple's attributes in
4645 * fdw_scan_tlist, i.e., one entry for every attribute of the result
4646 * tuple. We store zero for any attributes that don't have the
4647 * corresponding entries in that list, marking that a NULL is needed in
4648 * the result tuple.
4649 *
4650 * Also get the indexes of the entries for ctid and oid if any.
4651 */
4654
4656
4657 i = 1;
4660 {
4663
4665
4666 /*
4667 * If the Var is a column of the target relation to be retrieved from
4668 * the foreign server, get the index of the entry.
4669 */
4670 if (var->varno == rtindex &&
4672 {
4674
4676 {
4677 /*
4678 * We don't retrieve system columns other than ctid and oid.
4679 */
4682 else
4685 }
4686 else
4687 {
4688 /*
4689 * We don't retrieve whole-row references to the target
4690 * relation either.
4691 */
4693
4695 }
4696 }
4697 i++;
4698 }
4699}
References Assert, fb(), i, IsA, lfirst, list_member_int(), palloc0(), RelationGetDescr, SelfItemPointerAttributeNumber, Var::varattno, and Var::varno.
Referenced by postgresBeginDirectModify().
◆ make_tuple_from_result_row()
|
static |
Definition at line 7491 of file postgres_fdw.c.
7498{
7499 HeapTuple tuple;
7500 TupleDesc tupdesc;
7502 bool *nulls;
7505 ErrorContextCallback errcallback;
7506 MemoryContext oldcontext;
7509
7511
7512 /*
7513 * Do the following work in a temp context that we reset after each tuple.
7514 * This cleans up not only the data we have direct access to, but any
7515 * cruft the I/O functions might leak.
7516 */
7518
7519 /*
7520 * Get the tuple descriptor for the row. Use the rel's tupdesc if rel is
7521 * provided, otherwise look to the scan node's ScanTupleSlot.
7522 */
7523 if (rel)
7524 tupdesc = RelationGetDescr(rel);
7525 else
7526 {
7527 Assert(fsstate);
7529 }
7530
7533 /* Initialize to nulls for any columns not present in result */
7535
7536 /*
7537 * Set up and install callback to report where conversion error occurs.
7538 */
7539 errpos.cur_attno = 0;
7540 errpos.rel = rel;
7541 errpos.fsstate = fsstate;
7545 error_context_stack = &errcallback;
7546
7547 /*
7548 * i indexes columns in the relation, j indexes columns in the PGresult.
7549 */
7550 j = 0;
7552 {
7555
7556 /* fetch next column's textual value */
7559 else
7561
7562 /*
7563 * convert value to internal representation
7564 *
7565 * Note: we ignore system columns other than ctid and oid in result
7566 */
7569 {
7570 /* ordinary column */
7573 /* Apply the input function even to nulls, to support domains */
7575 valstr,
7578 }
7580 {
7581 /* ctid */
7583 {
7584 Datum datum;
7585
7588 }
7589 }
7590 errpos.cur_attno = 0;
7591
7592 j++;
7593 }
7594
7595 /* Uninstall error context callback. */
7597
7598 /*
7599 * Check we got the expected number of columns. Note: j == 0 and
7600 * PQnfields == 1 is expected, since deparse emits a NULL if no columns.
7601 */
7604
7605 /*
7606 * Build the result tuple in caller's memory context.
7607 */
7608 MemoryContextSwitchTo(oldcontext);
7609
7611
7612 /*
7613 * If we have a CTID to return, install it in both t_self and t_ctid.
7614 * t_self is the normal place, but if the tuple is converted to a
7615 * composite Datum, t_self will be lost; setting t_ctid allows CTID to be
7616 * preserved during EvalPlanQual re-evaluations (see ROW_MARK_COPY code).
7617 */
7618 if (ctid)
7620
7621 /*
7622 * Stomp on the xmin, xmax, and cmin fields from the tuple created by
7623 * heap_form_tuple. heap_form_tuple actually creates the tuple with
7624 * DatumTupleFields, not HeapTupleFields, but the executor expects
7625 * HeapTupleFields and will happily extract system columns on that
7626 * assumption. If we don't do this then, for example, the tuple length
7627 * ends up in the xmin field, which isn't what we want.
7628 */
7632
7633 /* Clean up */
7635
7636 return tuple;
7637}
Datum InputFunctionCall(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod)
Definition fmgr.c:1531
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
Definition heaptuple.c:1117
static void conversion_error_callback(void *arg)
Definition postgres_fdw.c:7648
Definition elog.h:296
References ErrorContextCallback::arg, Assert, AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, ErrorContextCallback::callback, conversion_error_callback(), CStringGetDatum(), DatumGetPointer(), DirectFunctionCall1, elog, ERROR, error_context_stack, fb(), heap_form_tuple(), HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), i, InputFunctionCall(), InvalidTransactionId, j, lfirst_int, MemoryContextReset(), MemoryContextSwitchTo(), TupleDescData::natts, palloc(), palloc0(), PQgetisnull, PQgetvalue, PQnfields, PQntuples, ErrorContextCallback::previous, RelationGetDescr, SelfItemPointerAttributeNumber, ForeignScanState::ss, ScanState::ss_ScanTupleSlot, HeapTupleHeaderData::t_ctid, HeapTupleData::t_data, HeapTupleData::t_self, tidin(), TupleTableSlot::tts_tupleDescriptor, and values.
Referenced by analyze_row_processor(), fetch_more_data(), get_returning_data(), and store_returning_result().
◆ merge_fdw_options()
|
static |
Definition at line 6202 of file postgres_fdw.c.
6205{
6206 /* We must always have fpinfo_o. */
6208
6209 /* fpinfo_i may be NULL, but if present the servers must both match. */
6212
6213 /*
6214 * Copy the server specific FDW options. (For a join, both relations come
6215 * from the same server, so the server options should have the same value
6216 * for both relations.)
6217 */
6224
6225 /* Merge the table level options from either side of the join. */
6227 {
6228 /*
6229 * We'll prefer to use remote estimates for this join if any table
6230 * from either side of the join is using remote estimates. This is
6231 * most likely going to be preferred since they're already willing to
6232 * pay the price of a round trip to get the remote EXPLAIN. In any
6233 * case it's not entirely clear how we might otherwise handle this
6234 * best.
6235 */
6237 fpinfo_i->use_remote_estimate;
6238
6239 /*
6240 * Set fetch size to maximum of the joining sides, since we are
6241 * expecting the rows returned by the join to be proportional to the
6242 * relation sizes.
6243 */
6245
6246 /*
6247 * We'll prefer to consider this join async-capable if any table from
6248 * either side of the join is considered async-capable. This would be
6249 * reasonable because in that case the foreign server would have its
6250 * own resources to scan that table asynchronously, and the join could
6251 * also be computed asynchronously using the resources.
6252 */
6254 fpinfo_i->async_capable;
6255 }
6256}
References Assert, fb(), and Max.
Referenced by add_foreign_final_paths(), add_foreign_grouping_paths(), add_foreign_ordered_paths(), and foreign_join_ok().
◆ PG_FUNCTION_INFO_V1()
| PG_FUNCTION_INFO_V1 | ( | postgres_fdw_handler | ) |
◆ PG_MODULE_MAGIC_EXT()
| PG_MODULE_MAGIC_EXT | ( | . | name = "postgres_fdw", |
| . | version = PG_VERSION |
||
| ) |
◆ postgres_fdw_handler()
| Datum postgres_fdw_handler | ( | PG_FUNCTION_ARGS | ) |
Definition at line 555 of file postgres_fdw.c.
556{
558
559 /* Functions for scanning foreign tables */
567
568 /* Functions for updating foreign tables */
585
586 /* Function for EvalPlanQual rechecks */
588 /* Support functions for EXPLAIN */
592
593 /* Support function for TRUNCATE */
595
596 /* Support functions for ANALYZE */
598
599 /* Support functions for IMPORT FOREIGN SCHEMA */
601
602 /* Support functions for join push-down */
604
605 /* Support functions for upper relation push-down */
607
608 /* Support functions for asynchronous execution */
613
614 PG_RETURN_POINTER(routine);
615}
static int postgresGetForeignModifyBatchSize(ResultRelInfo *resultRelInfo)
Definition postgres_fdw.c:2034
static void postgresBeginForeignScan(ForeignScanState *node, int eflags)
Definition postgres_fdw.c:1499
static bool postgresIsForeignPathAsyncCapable(ForeignPath *path)
Definition postgres_fdw.c:7188
static void postgresExecForeignTruncate(List *rels, DropBehavior behavior, bool restart_seqs)
Definition postgres_fdw.c:2983
static void postgresExplainForeignModify(ModifyTableState *mtstate, ResultRelInfo *rinfo, List *fdw_private, int subplan_index, ExplainState *es)
Definition postgres_fdw.c:2937
static TupleTableSlot ** postgresExecForeignBatchInsert(EState *estate, ResultRelInfo *resultRelInfo, TupleTableSlot **slots, TupleTableSlot **planSlots, int *numSlots)
Definition postgres_fdw.c:2001
static void postgresGetForeignJoinPaths(PlannerInfo *root, RelOptInfo *joinrel, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinType jointype, JoinPathExtraData *extra)
Definition postgres_fdw.c:6263
static void postgresExplainForeignScan(ForeignScanState *node, ExplainState *es)
Definition postgres_fdw.c:2830
static TupleTableSlot * postgresExecForeignUpdate(EState *estate, ResultRelInfo *resultRelInfo, TupleTableSlot *slot, TupleTableSlot *planSlot)
Definition postgres_fdw.c:2101
static bool postgresPlanDirectModify(PlannerInfo *root, ModifyTable *plan, Index resultRelation, int subplan_index)
Definition postgres_fdw.c:2448
static void postgresReScanForeignScan(ForeignScanState *node)
Definition postgres_fdw.c:1649
static void postgresForeignAsyncRequest(AsyncRequest *areq)
Definition postgres_fdw.c:7201
static int postgresIsForeignRelUpdatable(Relation rel)
Definition postgres_fdw.c:2312
static ForeignScan * postgresGetForeignPlan(PlannerInfo *root, RelOptInfo *foreignrel, Oid foreigntableid, ForeignPath *best_path, List *tlist, List *scan_clauses, Plan *outer_plan)
Definition postgres_fdw.c:1230
static void postgresEndForeignScan(ForeignScanState *node)
Definition postgres_fdw.c:1723
static void postgresGetForeignPaths(PlannerInfo *root, RelOptInfo *baserel, Oid foreigntableid)
Definition postgres_fdw.c:1016
static List * postgresPlanForeignModify(PlannerInfo *root, ModifyTable *plan, Index resultRelation, int subplan_index)
Definition postgres_fdw.c:1776
static void postgresEndForeignModify(EState *estate, ResultRelInfo *resultRelInfo)
Definition postgres_fdw.c:2139
static void postgresAddForeignUpdateTargets(PlannerInfo *root, Index rtindex, RangeTblEntry *target_rte, Relation target_relation)
Definition postgres_fdw.c:1748
static void postgresGetForeignRelSize(PlannerInfo *root, RelOptInfo *baserel, Oid foreigntableid)
Definition postgres_fdw.c:625
static void postgresEndDirectModify(ForeignScanState *node)
Definition postgres_fdw.c:2807
static void postgresForeignAsyncConfigureWait(AsyncRequest *areq)
Definition postgres_fdw.c:7211
static void postgresGetForeignUpperPaths(PlannerInfo *root, UpperRelationKind stage, RelOptInfo *input_rel, RelOptInfo *output_rel, void *extra)
Definition postgres_fdw.c:6648
static void postgresForeignAsyncNotify(AsyncRequest *areq)
Definition postgres_fdw.c:7288
static TupleTableSlot * postgresIterateForeignScan(ForeignScanState *node)
Definition postgres_fdw.c:1604
static TupleTableSlot * postgresExecForeignDelete(EState *estate, ResultRelInfo *resultRelInfo, TupleTableSlot *slot, TupleTableSlot *planSlot)
Definition postgres_fdw.c:2120
static bool postgresRecheckForeignScan(ForeignScanState *node, TupleTableSlot *slot)
Definition postgres_fdw.c:2356
static List * postgresImportForeignSchema(ImportForeignSchemaStmt *stmt, Oid serverOid)
Definition postgres_fdw.c:5373
static bool postgresAnalyzeForeignTable(Relation relation, AcquireSampleRowsFunc *func, BlockNumber *totalpages)
Definition postgres_fdw.c:4890
static void postgresBeginForeignModify(ModifyTableState *mtstate, ResultRelInfo *resultRelInfo, List *fdw_private, int subplan_index, int eflags)
Definition postgres_fdw.c:1915
static void postgresBeginForeignInsert(ModifyTableState *mtstate, ResultRelInfo *resultRelInfo)
Definition postgres_fdw.c:2157
static TupleTableSlot * postgresIterateDirectModify(ForeignScanState *node)
Definition postgres_fdw.c:2763
static void postgresBeginDirectModify(ForeignScanState *node, int eflags)
Definition postgres_fdw.c:2646
static TupleTableSlot * postgresExecForeignInsert(EState *estate, ResultRelInfo *resultRelInfo, TupleTableSlot *slot, TupleTableSlot *planSlot)
Definition postgres_fdw.c:1972
static void postgresEndForeignInsert(EState *estate, ResultRelInfo *resultRelInfo)
Definition postgres_fdw.c:2288
static void postgresExplainDirectModify(ForeignScanState *node, ExplainState *es)
Definition postgres_fdw.c:2965
Definition fdwapi.h:205
AddForeignUpdateTargets_function AddForeignUpdateTargets
Definition fdwapi.h:229
ForeignAsyncRequest_function ForeignAsyncRequest
Definition fdwapi.h:278
IterateDirectModify_function IterateDirectModify
Definition fdwapi.h:243
GetForeignJoinPaths_function GetForeignJoinPaths
Definition fdwapi.h:223
ExecForeignBatchInsert_function ExecForeignBatchInsert
Definition fdwapi.h:233
GetForeignModifyBatchSize_function GetForeignModifyBatchSize
Definition fdwapi.h:234
AnalyzeForeignTable_function AnalyzeForeignTable
Definition fdwapi.h:257
ExplainForeignModify_function ExplainForeignModify
Definition fdwapi.h:253
IsForeignPathAsyncCapable_function IsForeignPathAsyncCapable
Definition fdwapi.h:277
ImportForeignSchema_function ImportForeignSchema
Definition fdwapi.h:260
ExecForeignTruncate_function ExecForeignTruncate
Definition fdwapi.h:263
ExplainDirectModify_function ExplainDirectModify
Definition fdwapi.h:254
IsForeignRelUpdatable_function IsForeignRelUpdatable
Definition fdwapi.h:240
GetForeignUpperPaths_function GetForeignUpperPaths
Definition fdwapi.h:226
ForeignAsyncConfigureWait_function ForeignAsyncConfigureWait
Definition fdwapi.h:279
References FdwRoutine::AddForeignUpdateTargets, FdwRoutine::AnalyzeForeignTable, FdwRoutine::BeginDirectModify, FdwRoutine::BeginForeignInsert, FdwRoutine::BeginForeignModify, FdwRoutine::BeginForeignScan, FdwRoutine::EndDirectModify, FdwRoutine::EndForeignInsert, FdwRoutine::EndForeignModify, FdwRoutine::EndForeignScan, FdwRoutine::ExecForeignBatchInsert, FdwRoutine::ExecForeignDelete, FdwRoutine::ExecForeignInsert, FdwRoutine::ExecForeignTruncate, FdwRoutine::ExecForeignUpdate, FdwRoutine::ExplainDirectModify, FdwRoutine::ExplainForeignModify, FdwRoutine::ExplainForeignScan, FdwRoutine::ForeignAsyncConfigureWait, FdwRoutine::ForeignAsyncNotify, FdwRoutine::ForeignAsyncRequest, FdwRoutine::GetForeignJoinPaths, FdwRoutine::GetForeignModifyBatchSize, FdwRoutine::GetForeignPaths, FdwRoutine::GetForeignPlan, FdwRoutine::GetForeignRelSize, FdwRoutine::GetForeignUpperPaths, FdwRoutine::ImportForeignSchema, FdwRoutine::IsForeignPathAsyncCapable, FdwRoutine::IsForeignRelUpdatable, FdwRoutine::IterateDirectModify, FdwRoutine::IterateForeignScan, makeNode, PG_RETURN_POINTER, FdwRoutine::PlanDirectModify, FdwRoutine::PlanForeignModify, postgresAddForeignUpdateTargets(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignInsert(), postgresBeginForeignModify(), postgresBeginForeignScan(), postgresEndDirectModify(), postgresEndForeignInsert(), postgresEndForeignModify(), postgresEndForeignScan(), postgresExecForeignBatchInsert(), postgresExecForeignDelete(), postgresExecForeignInsert(), postgresExecForeignTruncate(), postgresExecForeignUpdate(), postgresExplainDirectModify(), postgresExplainForeignModify(), postgresExplainForeignScan(), postgresForeignAsyncConfigureWait(), postgresForeignAsyncNotify(), postgresForeignAsyncRequest(), postgresGetForeignJoinPaths(), postgresGetForeignModifyBatchSize(), postgresGetForeignPaths(), postgresGetForeignPlan(), postgresGetForeignRelSize(), postgresGetForeignUpperPaths(), postgresImportForeignSchema(), postgresIsForeignPathAsyncCapable(), postgresIsForeignRelUpdatable(), postgresIterateDirectModify(), postgresIterateForeignScan(), postgresPlanDirectModify(), postgresPlanForeignModify(), postgresRecheckForeignScan(), postgresReScanForeignScan(), FdwRoutine::RecheckForeignScan, and FdwRoutine::ReScanForeignScan.
◆ postgresAcquireSampleRowsFunc()
|
static |
Definition at line 5008 of file postgres_fdw.c.
5012{
5013 PgFdwAnalyzeState astate;
5015 ForeignServer *server;
5021 double reltuples = -1.0;
5023 StringInfoData sql;
5024 PGresult *res;
5028
5029 /* Initialize workspace state */
5030 astate.rel = relation;
5032
5033 astate.rows = rows;
5034 astate.targrows = targrows;
5035 astate.numrows = 0;
5036 astate.samplerows = 0;
5039
5040 /* Remember ANALYZE context, and create a per-tuple temp context */
5043 "postgres_fdw temporary data",
5044 ALLOCSET_SMALL_SIZES);
5045
5046 /*
5047 * Get the connection to use. We do the remote access as the table's
5048 * owner, even if the ANALYZE was started by some other user.
5049 */
5054
5055 /* We'll need server version, so fetch it now. */
5057
5058 /*
5059 * What sampling method should we use?
5060 */
5062 {
5064
5066 {
5068
5070 method = ANALYZE_SAMPLE_OFF;
5072 method = ANALYZE_SAMPLE_AUTO;
5074 method = ANALYZE_SAMPLE_RANDOM;
5076 method = ANALYZE_SAMPLE_SYSTEM;
5078 method = ANALYZE_SAMPLE_BERNOULLI;
5079
5080 break;
5081 }
5082 }
5083
5085 {
5087
5089 {
5091
5093 method = ANALYZE_SAMPLE_OFF;
5095 method = ANALYZE_SAMPLE_AUTO;
5097 method = ANALYZE_SAMPLE_RANDOM;
5099 method = ANALYZE_SAMPLE_SYSTEM;
5101 method = ANALYZE_SAMPLE_BERNOULLI;
5102
5103 break;
5104 }
5105 }
5106
5107 /*
5108 * Error-out if explicitly required one of the TABLESAMPLE methods, but
5109 * the server does not support it.
5110 */
5112 (method == ANALYZE_SAMPLE_SYSTEM ||
5113 method == ANALYZE_SAMPLE_BERNOULLI))
5117
5118 /*
5119 * If we've decided to do remote sampling, calculate the sampling rate. We
5120 * need to get the number of tuples from the remote server, but skip that
5121 * network round-trip if not needed.
5122 */
5124 {
5126
5127 reltuples = postgresGetAnalyzeInfoForForeignTable(relation,
5128 &can_tablesample);
5129
5130 /*
5131 * Make sure we're not choosing TABLESAMPLE when the remote relation
5132 * does not support that. But only do this for "auto" - if the user
5133 * explicitly requested BERNOULLI/SYSTEM, it's better to fail.
5134 */
5136 method = ANALYZE_SAMPLE_RANDOM;
5137
5138 /*
5139 * Remote's reltuples could be 0 or -1 if the table has never been
5140 * vacuumed/analyzed. In that case, disable sampling after all.
5141 */
5142 if ((reltuples <= 0) || (targrows >= reltuples))
5143 method = ANALYZE_SAMPLE_OFF;
5144 else
5145 {
5146 /*
5147 * All supported sampling methods require sampling rate, not
5148 * target rows directly, so we calculate that using the remote
5149 * reltuples value. That's imperfect, because it might be off a
5150 * good deal, but that's not something we can (or should) address
5151 * here.
5152 *
5153 * If reltuples is too low (i.e. when table grew), we'll end up
5154 * sampling more rows - but then we'll apply the local sampling,
5155 * so we get the expected sample size. This is the same outcome as
5156 * without remote sampling.
5157 *
5158 * If reltuples is too high (e.g. after bulk DELETE), we will end
5159 * up sampling too few rows.
5160 *
5161 * We can't really do much better here - we could try sampling a
5162 * bit more rows, but we don't know how off the reltuples value is
5163 * so how much is "a bit more"?
5164 *
5165 * Furthermore, the targrows value for partitions is determined
5166 * based on table size (relpages), which can be off in different
5167 * ways too. Adjusting the sampling rate here might make the issue
5168 * worse.
5169 */
5170 sample_frac = targrows / reltuples;
5171
5172 /*
5173 * We should never get sampling rate outside the valid range
5174 * (between 0.0 and 1.0), because those cases should be covered by
5175 * the previous branch that sets ANALYZE_SAMPLE_OFF.
5176 */
5178 }
5179 }
5180
5181 /*
5182 * For "auto" method, pick the one we believe is best. For servers with
5183 * TABLESAMPLE support we pick BERNOULLI, for old servers we fall-back to
5184 * random() to at least reduce network transfer.
5185 */
5187 {
5189 method = ANALYZE_SAMPLE_RANDOM;
5190 else
5191 method = ANALYZE_SAMPLE_BERNOULLI;
5192 }
5193
5194 /*
5195 * Construct cursor that retrieves whole rows from remote.
5196 */
5198 initStringInfo(&sql);
5200
5202
5206 PQclear(res);
5207
5208 /*
5209 * Determine the fetch size. The default is arbitrary, but shouldn't be
5210 * enormous.
5211 */
5212 fetch_size = 100;
5214 {
5216
5218 {
5220 break;
5221 }
5222 }
5224 {
5226
5228 {
5230 break;
5231 }
5232 }
5233
5234 /* Construct command to fetch rows from remote. */
5237
5238 /* Retrieve and process rows a batch at a time. */
5239 for (;;)
5240 {
5241 int numrows;
5243
5244 /* Allow users to cancel long query */
5245 CHECK_FOR_INTERRUPTS();
5246
5247 /*
5248 * XXX possible future improvement: if rowstoskip is large, we could
5249 * issue a MOVE rather than physically fetching the rows, then just
5250 * adjust rowstoskip and samplerows appropriately.
5251 */
5252
5253 /* Fetch some rows */
5255 /* On error, report the original query, not the FETCH. */
5258
5259 /* Process whatever we got. */
5260 numrows = PQntuples(res);
5263
5264 PQclear(res);
5265
5266 /* Must be EOF if we didn't get all the rows requested. */
5268 break;
5269 }
5270
5271 /* Close the cursor, just to be tidy. */
5273
5275
5276 /* We assume that we have no dead tuple. */
5277 *totaldeadrows = 0.0;
5278
5279 /*
5280 * Without sampling, we've retrieved all living tuples from foreign
5281 * server, so report that as totalrows. Otherwise use the reltuples
5282 * estimate we got from the remote side.
5283 */
5286 else
5287 *totalrows = reltuples;
5288
5289 /*
5290 * Emit some interesting relation info
5291 */
5292 ereport(elevel,
5294 RelationGetRelationName(relation),
5296
5298}
void deparseAnalyzeSql(StringInfo buf, Relation rel, PgFdwSamplingMethod sample_method, double sample_frac, List **retrieved_attrs)
Definition deparse.c:2592
static void analyze_row_processor(PGresult *res, int row, PgFdwAnalyzeState *astate)
Definition postgres_fdw.c:5306
static double postgresGetAnalyzeInfoForForeignTable(Relation relation, bool *can_tablesample)
Definition postgres_fdw.c:4946
static void close_cursor(PGconn *conn, unsigned int cursor_number, PgFdwConnState *conn_state)
Definition postgres_fdw.c:3938
void reservoir_init_selection_state(ReservoirState rs, int n)
Definition sampling.c:133
Definition postgres_fdw.c:257
References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, analyze_row_processor(), ANALYZE_SAMPLE_AUTO, ANALYZE_SAMPLE_BERNOULLI, ANALYZE_SAMPLE_OFF, ANALYZE_SAMPLE_RANDOM, ANALYZE_SAMPLE_SYSTEM, PgFdwAnalyzeState::anl_cxt, appendStringInfo(), Assert, PgFdwAnalyzeState::attinmeta, CHECK_FOR_INTERRUPTS, close_cursor(), conn, CurrentMemoryContext, cursor_number, StringInfoData::data, defGetString(), DefElem::defname, deparseAnalyzeSql(), ereport, errcode(), errmsg(), ERROR, fb(), fetch_size, GetConnection(), GetCursorNumber(), GetForeignServer(), GetForeignTable(), GetUserMapping(), i, initStringInfo(), lfirst, PgFdwAnalyzeState::numrows, ForeignServer::options, parse_int(), pgfdw_exec_query(), pgfdw_report_error(), PGRES_COMMAND_OK, PGRES_TUPLES_OK, postgresGetAnalyzeInfoForForeignTable(), PQclear, PQntuples, PQresultStatus, PQserverVersion(), RelationData::rd_rel, PgFdwAnalyzeState::rel, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ReleaseConnection(), reservoir_init_selection_state(), PgFdwAnalyzeState::retrieved_attrs, PgFdwAnalyzeState::rows, PgFdwAnalyzeState::rowstoskip, PgFdwAnalyzeState::rstate, PgFdwAnalyzeState::samplerows, server_version_num, snprintf, table, PgFdwAnalyzeState::targrows, PgFdwAnalyzeState::temp_cxt, TupleDescGetAttInMetadata(), user, and value.
Referenced by postgresAnalyzeForeignTable().
◆ postgresAddForeignUpdateTargets()
|
static |
Definition at line 1748 of file postgres_fdw.c.
1752{
1753 Var *var;
1754
1755 /*
1756 * In postgres_fdw, what we need is the ctid, same as for a regular table.
1757 */
1758
1759 /* Make a Var representing the desired value */
1760 var = makeVar(rtindex,
1762 TIDOID,
1763 -1,
1764 InvalidOid,
1765 0);
1766
1767 /* Register it as a row-identity column needed by this target rel */
1769}
void add_row_identity_var(PlannerInfo *root, Var *orig_var, Index rtindex, const char *rowid_name)
Definition appendinfo.c:859
References add_row_identity_var(), fb(), InvalidOid, makeVar(), root, and SelfItemPointerAttributeNumber.
Referenced by postgres_fdw_handler().
◆ postgresAnalyzeForeignTable()
|
static |
Definition at line 4890 of file postgres_fdw.c.
4893{
4897 StringInfoData sql;
4898 PGresult *res;
4899
4900 /* Return the row-analysis function pointer */
4901 *func = postgresAcquireSampleRowsFunc;
4902
4903 /*
4904 * Now we have to get the number of pages. It's annoying that the ANALYZE
4905 * API requires us to return that now, because it forces some duplication
4906 * of effort between this routine and postgresAcquireSampleRowsFunc. But
4907 * it's probably not worth redefining that API at this point.
4908 */
4909
4910 /*
4911 * Get the connection to use. We do the remote access as the table's
4912 * owner, even if the ANALYZE was started by some other user.
4913 */
4917
4918 /*
4919 * Construct command to get page count for relation.
4920 */
4921 initStringInfo(&sql);
4922 deparseAnalyzeSizeSql(&sql, relation);
4923
4927
4931 PQclear(res);
4932
4934
4935 return true;
4936}
void deparseAnalyzeSizeSql(StringInfo buf, Relation rel)
Definition deparse.c:2530
static int postgresAcquireSampleRowsFunc(Relation relation, int elevel, HeapTuple *rows, int targrows, double *totalrows, double *totaldeadrows)
Definition postgres_fdw.c:5008
References conn, StringInfoData::data, deparseAnalyzeSizeSql(), elog, ERROR, fb(), GetConnection(), GetForeignTable(), GetUserMapping(), initStringInfo(), pgfdw_exec_query(), pgfdw_report_error(), PGRES_TUPLES_OK, postgresAcquireSampleRowsFunc(), PQclear, PQgetvalue, PQnfields, PQntuples, PQresultStatus, RelationData::rd_rel, RelationGetRelid, ReleaseConnection(), table, and user.
Referenced by postgres_fdw_handler().
◆ postgresBeginDirectModify()
|
static |
Definition at line 2646 of file postgres_fdw.c.
2647{
2651 Index rtindex;
2652 Oid userid;
2655 int numParams;
2656
2657 /*
2658 * Do nothing in EXPLAIN (no ANALYZE) case. node->fdw_state stays NULL.
2659 */
2661 return;
2662
2663 /*
2664 * We'll save private state in node->fdw_state.
2665 */
2668
2669 /*
2670 * Identify which user to do the remote access as. This should match what
2671 * ExecCheckPermissions() does.
2672 */
2674
2675 /* Get info about foreign table. */
2679 else
2683
2684 /*
2685 * Get connection to the foreign server. Connection manager will
2686 * establish new connection if necessary.
2687 */
2689
2690 /* Update the foreign-join-related fields. */
2692 {
2693 /* Save info about foreign table. */
2695
2696 /*
2697 * Set dmstate->rel to NULL to teach get_returning_data() and
2698 * make_tuple_from_result_row() that columns fetched from the remote
2699 * server are described by fdw_scan_tlist of the foreign-scan plan
2700 * node, not the tuple descriptor for the target relation.
2701 */
2703 }
2704
2705 /* Initialize state variable */
2707
2708 /* Get private info created by planner functions. */
2710 FdwDirectModifyPrivateUpdateSql));
2717
2718 /* Create context for per-tuple temp workspace. */
2720 "postgres_fdw temporary data",
2721 ALLOCSET_SMALL_SIZES);
2722
2723 /* Prepare for input conversion of RETURNING results. */
2725 {
2726 TupleDesc tupdesc;
2727
2729 tupdesc = get_tupdesc_for_join_scan_tuples(node);
2730 else
2732
2734
2735 /*
2736 * When performing an UPDATE/DELETE .. RETURNING on a join directly,
2737 * initialize a filter to extract an updated/deleted tuple from a scan
2738 * tuple.
2739 */
2742 }
2743
2744 /*
2745 * Prepare for processing of parameters used in remote query, if any.
2746 */
2748 dmstate->numParams = numParams;
2749 if (numParams > 0)
2751 fsplan->fdw_exprs,
2752 numParams,
2753 &dmstate->param_flinfo,
2754 &dmstate->param_exprs,
2755 &dmstate->param_values);
2756}
Relation ExecOpenScanRelation(EState *estate, Index scanrelid, int eflags)
Definition execUtils.c:742
static TupleDesc get_tupdesc_for_join_scan_tuples(ForeignScanState *node)
Definition postgres_fdw.c:1447
static void prepare_query_params(PlanState *node, List *fdw_exprs, int numParams, FmgrInfo **param_flinfo, List **param_exprs, const char ***param_values)
Definition postgres_fdw.c:4804
static void init_returning_filter(PgFdwDirectModifyState *dmstate, List *fdw_scan_tlist, Index rtindex)
Definition postgres_fdw.c:4632
Definition execnodes.h:1162
References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, boolVal, EState::es_query_cxt, EXEC_FLAG_EXPLAIN_ONLY, ExecOpenScanRelation(), fb(), ForeignScanState::fdw_state, FdwDirectModifyPrivateHasReturning, FdwDirectModifyPrivateRetrievedAttrs, FdwDirectModifyPrivateSetProcessed, FdwDirectModifyPrivateUpdateSql, get_tupdesc_for_join_scan_tuples(), GetConnection(), GetForeignTable(), GetUserId(), GetUserMapping(), init_returning_filter(), list_length(), list_nth(), OidIsValid, palloc0_object, PlanState::plan, prepare_query_params(), ScanState::ps, RelationGetDescr, RelationGetRelid, ForeignScanState::resultRelInfo, ResultRelInfo::ri_RangeTableIndex, ForeignScanState::ss, ScanState::ss_currentRelation, PlanState::state, strVal, table, TupleDescGetAttInMetadata(), and user.
Referenced by postgres_fdw_handler().
◆ postgresBeginForeignInsert()
|
static |
Definition at line 2157 of file postgres_fdw.c.
2159{
2163 Index resultRelation;
2169 StringInfoData sql;
2173
2174 /*
2175 * If the foreign table we are about to insert routed rows into is also an
2176 * UPDATE subplan result rel that will be updated later, proceeding with
2177 * the INSERT will result in the later UPDATE incorrectly modifying those
2178 * routed rows, so prevent the INSERT --- it would be nice if we could
2179 * handle this case; but for now, throw an error for safety.
2180 */
2182 (resultRelInfo->ri_usesFdwDirectModify ||
2183 resultRelInfo->ri_FdwState))
2187 RelationGetRelationName(rel))));
2188
2189 initStringInfo(&sql);
2190
2191 /* We transmit all columns that are defined in the foreign table. */
2193 {
2195
2198 }
2199
2200 /* Check if we add the ON CONFLICT clause to the remote query. */
2202 {
2204
2205 /* We only support DO NOTHING without an inference specification. */
2210 (int) onConflictAction);
2211 }
2212
2213 /*
2214 * If the foreign table is a partition that doesn't have a corresponding
2215 * RTE entry, we need to create a new RTE describing the foreign table for
2216 * use by deparseInsertSql and create_foreign_modify() below, after first
2217 * copying the parent's RTE and modifying some fields to describe the
2218 * foreign partition to work on. However, if this is invoked by UPDATE,
2219 * the existing RTE may already correspond to this partition if it is one
2220 * of the UPDATE subplan target rels; in that case, we can just use the
2221 * existing RTE as-is.
2222 */
2224 {
2226
2231
2232 /*
2233 * For UPDATE, we must use the RT index of the first subplan target
2234 * rel's RTE, because the core code would have built expressions for
2235 * the partition, such as RETURNING, using that RT index as varno of
2236 * Vars contained in those expressions.
2237 */
2241 else
2242 resultRelation = rootResultRelInfo->ri_RangeTableIndex;
2243 }
2244 else
2245 {
2246 resultRelation = resultRelInfo->ri_RangeTableIndex;
2248 }
2249
2250 /* Construct the SQL command string. */
2252 resultRelInfo->ri_WithCheckOptions,
2253 resultRelInfo->ri_returningList,
2254 &retrieved_attrs, &values_end_len);
2255
2256 /* Construct an execution state. */
2258 rte,
2259 resultRelInfo,
2260 CMD_INSERT,
2261 NULL,
2262 sql.data,
2263 targetAttrs,
2264 values_end_len,
2265 retrieved_attrs != NIL,
2266 retrieved_attrs);
2267
2268 /*
2269 * If the given resultRelInfo already has PgFdwModifyState set, it means
2270 * the foreign table is an UPDATE subplan result rel; in which case, store
2271 * the resulting state into the aux_fmstate of the PgFdwModifyState.
2272 */
2274 {
2278 }
2279 else
2281}
void deparseInsertSql(StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, List *targetAttrs, bool doNothing, List *withCheckOptionList, List *returningList, List **retrieved_attrs, int *values_end_len)
Definition deparse.c:2114
static PgFdwModifyState * create_foreign_modify(EState *estate, RangeTblEntry *rte, ResultRelInfo *resultRelInfo, CmdType operation, Plan *subplan, char *query, List *target_attrs, int values_end, bool has_returning, List *retrieved_attrs)
Definition postgres_fdw.c:3957
Definition plannodes.h:331
struct ResultRelInfo * ri_RootResultRelInfo
Definition execnodes.h:620
References Assert, CompactAttribute::attisdropped, attnum, castNode, CMD_INSERT, CMD_UPDATE, copyObject, create_foreign_modify(), StringInfoData::data, deparseInsertSql(), elog, ereport, errcode(), errmsg(), ERROR, exec_rt_fetch(), fb(), initStringInfo(), lappend_int(), TupleDescData::natts, NIL, ONCONFLICT_NONE, ONCONFLICT_NOTHING, PlanState::plan, plan, ModifyTableState::ps, RelationGetDescr, RelationGetRelationName, RelationGetRelid, ModifyTableState::resultRelInfo, ResultRelInfo::ri_FdwState, ResultRelInfo::ri_RangeTableIndex, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_returningList, ResultRelInfo::ri_RootResultRelInfo, ResultRelInfo::ri_usesFdwDirectModify, ResultRelInfo::ri_WithCheckOptions, PlanState::state, and TupleDescCompactAttr().
Referenced by postgres_fdw_handler().
◆ postgresBeginForeignModify()
|
static |
Definition at line 1915 of file postgres_fdw.c.
1920{
1922 char *query;
1923 List *target_attrs;
1924 bool has_returning;
1926 List *retrieved_attrs;
1928
1929 /*
1930 * Do nothing in EXPLAIN (no ANALYZE) case. resultRelInfo->ri_FdwState
1931 * stays NULL.
1932 */
1934 return;
1935
1936 /* Deconstruct fdw_private data. */
1938 FdwModifyPrivateUpdateSql));
1942 FdwModifyPrivateLen));
1944 FdwModifyPrivateHasReturning));
1947
1948 /* Find RTE. */
1951
1952 /* Construct an execution state. */
1954 rte,
1955 resultRelInfo,
1956 mtstate->operation,
1958 query,
1959 target_attrs,
1960 values_end_len,
1961 has_returning,
1962 retrieved_attrs);
1963
1965}
References boolVal, create_foreign_modify(), EXEC_FLAG_EXPLAIN_ONLY, exec_rt_fetch(), fb(), FdwModifyPrivateHasReturning, FdwModifyPrivateLen, FdwModifyPrivateRetrievedAttrs, FdwModifyPrivateTargetAttnums, FdwModifyPrivateUpdateSql, intVal, list_nth(), ModifyTableState::operation, outerPlanState, plan, ModifyTableState::ps, ResultRelInfo::ri_FdwState, ResultRelInfo::ri_RangeTableIndex, PlanState::state, and strVal.
Referenced by postgres_fdw_handler().
◆ postgresBeginForeignScan()
|
static |
Definition at line 1499 of file postgres_fdw.c.
1500{
1503 PgFdwScanState *fsstate;
1505 Oid userid;
1508 int rtindex;
1509 int numParams;
1510
1511 /*
1512 * Do nothing in EXPLAIN (no ANALYZE) case. node->fdw_state stays NULL.
1513 */
1515 return;
1516
1517 /*
1518 * We'll save private state in node->fdw_state.
1519 */
1521 node->fdw_state = fsstate;
1522
1523 /*
1524 * Identify which user to do the remote access as. This should match what
1525 * ExecCheckPermissions() does.
1526 */
1529 rtindex = fsplan->scan.scanrelid;
1530 else
1533
1534 /* Get info about foreign table. */
1537
1538 /*
1539 * Get connection to the foreign server. Connection manager will
1540 * establish new connection if necessary.
1541 */
1543
1544 /* Assign a unique ID for my cursor */
1547
1548 /* Get private info created by planner functions. */
1550 FdwScanPrivateSelectSql));
1552 FdwScanPrivateRetrievedAttrs);
1554 FdwScanPrivateFetchSize));
1555
1556 /* Create contexts for batches of tuples and per-tuple temp workspace. */
1558 "postgres_fdw tuple data",
1559 ALLOCSET_DEFAULT_SIZES);
1561 "postgres_fdw temporary data",
1562 ALLOCSET_SMALL_SIZES);
1563
1564 /*
1565 * Get info we'll need for converting data fetched from the foreign server
1566 * into local representation and error reporting during that process.
1567 */
1569 {
1572 }
1573 else
1574 {
1577 }
1578
1580
1581 /*
1582 * Prepare for processing of parameters used in remote query, if any.
1583 */
1585 fsstate->numParams = numParams;
1586 if (numParams > 0)
1588 fsplan->fdw_exprs,
1589 numParams,
1590 &fsstate->param_flinfo,
1591 &fsstate->param_exprs,
1592 &fsstate->param_values);
1593
1594 /* Set the async-capable flag */
1596}
References ALLOCSET_DEFAULT_SIZES, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, PgFdwScanState::async_capable, PlanState::async_capable, PgFdwScanState::attinmeta, PgFdwScanState::batch_cxt, bms_next_member(), PgFdwScanState::conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_exists, PgFdwScanState::cursor_number, EState::es_query_cxt, EXEC_FLAG_EXPLAIN_ONLY, exec_rt_fetch(), fb(), ForeignScanState::fdw_state, FdwScanPrivateFetchSize, FdwScanPrivateRetrievedAttrs, FdwScanPrivateSelectSql, PgFdwScanState::fetch_size, get_tupdesc_for_join_scan_tuples(), GetConnection(), GetCursorNumber(), GetForeignTable(), GetUserId(), GetUserMapping(), intVal, list_length(), list_nth(), PgFdwScanState::numParams, OidIsValid, palloc0_object, PgFdwScanState::param_exprs, PgFdwScanState::param_flinfo, PgFdwScanState::param_values, PlanState::plan, prepare_query_params(), ScanState::ps, PgFdwScanState::query, PgFdwScanState::rel, RelationGetDescr, PgFdwScanState::retrieved_attrs, ForeignScanState::ss, ScanState::ss_currentRelation, PlanState::state, strVal, table, PgFdwScanState::temp_cxt, PgFdwScanState::tupdesc, TupleDescGetAttInMetadata(), and user.
Referenced by postgres_fdw_handler().
◆ postgresEndDirectModify()
|
static |
Definition at line 2807 of file postgres_fdw.c.
2808{
2810
2811 /* if dmstate is NULL, we are in EXPLAIN; nothing to do */
2813 return;
2814
2815 /* Release PGresult */
2817
2818 /* Release remote connection */
2821
2822 /* MemoryContext will be deleted automatically. */
2823}
References fb(), ForeignScanState::fdw_state, PQclear, and ReleaseConnection().
Referenced by postgres_fdw_handler().
◆ postgresEndForeignInsert()
|
static |
Definition at line 2288 of file postgres_fdw.c.
2290{
2292
2294
2295 /*
2296 * If the fmstate has aux_fmstate set, get the aux_fmstate (see
2297 * postgresBeginForeignInsert())
2298 */
2301
2302 /* Destroy the execution state */
2304}
static void finish_foreign_modify(PgFdwModifyState *fmstate)
Definition postgres_fdw.c:4346
References Assert, fb(), finish_foreign_modify(), and ResultRelInfo::ri_FdwState.
Referenced by postgres_fdw_handler().
◆ postgresEndForeignModify()
|
static |
Definition at line 2139 of file postgres_fdw.c.
2141{
2143
2144 /* If fmstate is NULL, we are in EXPLAIN; nothing to do */
2146 return;
2147
2148 /* Destroy the execution state */
2150}
References fb(), finish_foreign_modify(), and ResultRelInfo::ri_FdwState.
Referenced by postgres_fdw_handler().
◆ postgresEndForeignScan()
|
static |
Definition at line 1723 of file postgres_fdw.c.
1724{
1726
1727 /* if fsstate is NULL, we are in EXPLAIN; nothing to do */
1729 return;
1730
1731 /* Close the cursor if open, to prevent accumulation of cursors */
1732 if (fsstate->cursor_exists)
1733 close_cursor(fsstate->conn, fsstate->cursor_number,
1734 fsstate->conn_state);
1735
1736 /* Release remote connection */
1737 ReleaseConnection(fsstate->conn);
1738 fsstate->conn = NULL;
1739
1740 /* MemoryContexts will be deleted automatically. */
1741}
References close_cursor(), PgFdwScanState::conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_exists, PgFdwScanState::cursor_number, fb(), ForeignScanState::fdw_state, and ReleaseConnection().
Referenced by postgres_fdw_handler().
◆ postgresExecForeignBatchInsert()
|
static |
Definition at line 2001 of file postgres_fdw.c.
2006{
2009
2010 /*
2011 * If the fmstate has aux_fmstate set, use the aux_fmstate (see
2012 * postgresBeginForeignInsert())
2013 */
2018 /* Revert that change */
2021
2023}
static TupleTableSlot ** execute_foreign_modify(EState *estate, ResultRelInfo *resultRelInfo, CmdType operation, TupleTableSlot **slots, TupleTableSlot **planSlots, int *numSlots)
Definition postgres_fdw.c:4077
References CMD_INSERT, execute_foreign_modify(), fb(), and ResultRelInfo::ri_FdwState.
Referenced by postgres_fdw_handler().
◆ postgresExecForeignDelete()
|
static |
Definition at line 2120 of file postgres_fdw.c.
References CMD_DELETE, execute_foreign_modify(), and fb().
Referenced by postgres_fdw_handler().
◆ postgresExecForeignInsert()
|
static |
Definition at line 1972 of file postgres_fdw.c.
1976{
1980
1981 /*
1982 * If the fmstate has aux_fmstate set, use the aux_fmstate (see
1983 * postgresBeginForeignInsert())
1984 */
1988 &slot, &planSlot, &numSlots);
1989 /* Revert that change */
1992
1994}
References CMD_INSERT, execute_foreign_modify(), fb(), and ResultRelInfo::ri_FdwState.
Referenced by postgres_fdw_handler().
◆ postgresExecForeignTruncate()
|
static |
Definition at line 2983 of file postgres_fdw.c.
2986{
2990 StringInfoData sql;
2993
2994 /*
2995 * By default, all postgres_fdw foreign tables are assumed truncatable.
2996 * This can be overridden by a per-server setting, which in turn can be
2997 * overridden by a per-table setting.
2998 */
3000 {
3004 ListCell *cell;
3006
3007 /*
3008 * First time through, determine whether the foreign server allows
3009 * truncates. Since all specified foreign tables are assumed to belong
3010 * to the same foreign server, this result can be used for other
3011 * foreign tables.
3012 */
3014 {
3015 serverid = table->serverid;
3016 server = GetForeignServer(serverid);
3017
3019 {
3021
3023 {
3025 break;
3026 }
3027 }
3028 }
3029
3030 /*
3031 * Confirm that all specified foreign tables belong to the same
3032 * foreign server.
3033 */
3035
3036 /* Determine whether this foreign table allows truncations */
3039 {
3041
3043 {
3045 break;
3046 }
3047 }
3048
3053 RelationGetRelationName(rel))));
3054 }
3056
3057 /*
3058 * Get connection to the foreign server. Connection manager will
3059 * establish new connection if necessary.
3060 */
3063
3064 /* Construct the TRUNCATE command string */
3065 initStringInfo(&sql);
3066 deparseTruncateSql(&sql, rels, behavior, restart_seqs);
3067
3068 /* Issue the TRUNCATE command to remote server */
3070
3072}
void deparseTruncateSql(StringInfo buf, List *rels, DropBehavior behavior, bool restart_seqs)
Definition deparse.c:2677
References Assert, conn, StringInfoData::data, defGetBoolean(), deparseTruncateSql(), do_sql_command(), ereport, errcode(), errmsg(), ERROR, fb(), GetConnection(), GetForeignServer(), GetForeignTable(), GetUserId(), GetUserMapping(), initStringInfo(), InvalidOid, lfirst, OidIsValid, ForeignServer::options, pfree(), RelationGetRelationName, RelationGetRelid, table, and user.
Referenced by postgres_fdw_handler().
◆ postgresExecForeignUpdate()
|
static |
Definition at line 2101 of file postgres_fdw.c.
References CMD_UPDATE, execute_foreign_modify(), and fb().
Referenced by postgres_fdw_handler().
◆ postgresExplainDirectModify()
|
static |
Definition at line 2965 of file postgres_fdw.c.
2966{
2967 List *fdw_private;
2968 char *sql;
2969
2971 {
2975 }
2976}
void ExplainPropertyText(const char *qlabel, const char *value, ExplainState *es)
Definition explain_format.c:214
References ExplainPropertyText(), FdwDirectModifyPrivateUpdateSql, list_nth(), PlanState::plan, ScanState::ps, ForeignScanState::ss, strVal, and ExplainState::verbose.
Referenced by postgres_fdw_handler().
◆ postgresExplainForeignModify()
|
static |
Definition at line 2937 of file postgres_fdw.c.
2942{
2944 {
2946 FdwModifyPrivateUpdateSql));
2947
2949
2950 /*
2951 * For INSERT we should always have batch size >= 1, but UPDATE and
2952 * DELETE don't support batching so don't show the property.
2953 */
2956 }
2957}
void ExplainPropertyInteger(const char *qlabel, const char *unit, int64 value, ExplainState *es)
Definition explain_format.c:223
References ExplainPropertyInteger(), ExplainPropertyText(), fb(), FdwModifyPrivateUpdateSql, list_nth(), ResultRelInfo::ri_BatchSize, strVal, and ExplainState::verbose.
Referenced by postgres_fdw_handler().
◆ postgresExplainForeignScan()
|
static |
Definition at line 2830 of file postgres_fdw.c.
2831{
2834
2835 /*
2836 * Identify foreign scans that are really joins or upper relations. The
2837 * input looks something like "(1) LEFT JOIN (2)", and we must replace the
2838 * digit string(s), which are RT indexes, with the correct relation names.
2839 * We do that here, not when the plan is created, because we can't know
2840 * what aliases ruleutils.c will assign at plan creation time.
2841 */
2843 {
2844 StringInfoData relations;
2846 char *ptr;
2848 rtoffset;
2849
2851
2852 /*
2853 * A difficulty with using a string representation of RT indexes is
2854 * that setrefs.c won't update the string when flattening the
2855 * rangetable. To find out what rtoffset was applied, identify the
2856 * minimum RT index appearing in the string and compare it to the
2857 * minimum member of plan->fs_base_relids. (We expect all the relids
2858 * in the join will have been offset by the same amount; the Asserts
2859 * below should catch it if that ever changes.)
2860 */
2862 ptr = rawrelations;
2863 while (*ptr)
2864 {
2866 {
2868
2870 minrti = rti;
2871 }
2872 else
2873 ptr++;
2874 }
2876
2877 /* Now we can translate the string */
2878 initStringInfo(&relations);
2879 ptr = rawrelations;
2880 while (*ptr)
2881 {
2883 {
2887 char *refname;
2888
2889 rti += rtoffset;
2893 /* This logic should agree with explain.c's ExplainTargetRel */
2896 {
2897 char *namespace;
2898
2903 }
2904 else
2905 appendStringInfoString(&relations,
2909 refname = rte->eref->aliasname;
2912 quote_identifier(refname));
2913 }
2914 else
2915 appendStringInfoChar(&relations, *ptr++);
2916 }
2918 }
2919
2920 /*
2921 * Add remote query, when VERBOSE option is specified.
2922 */
2924 {
2925 char *sql;
2926
2929 }
2930}
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, bms_is_member(), bms_next_member(), castNode, StringInfoData::data, ExplainPropertyText(), fb(), FdwScanPrivateRelations, FdwScanPrivateSelectSql, get_namespace_name_or_temp(), get_rel_name(), get_rel_namespace(), initStringInfo(), list_length(), list_nth(), PlanState::plan, plan, ScanState::ps, quote_identifier(), relname, rt_fetch, ExplainState::rtable, ExplainState::rtable_names, RTE_RELATION, ForeignScanState::ss, strVal, and ExplainState::verbose.
Referenced by postgres_fdw_handler().
◆ postgresForeignAsyncConfigureWait()
|
static |
Definition at line 7211 of file postgres_fdw.c.
7212{
7218
7219 /* This should not be called unless callback_pending */
7221
7222 /*
7223 * If process_pending_request() has been invoked on the given request
7224 * before we get here, we might have some tuples already; in which case
7225 * complete the request
7226 */
7228 {
7231 return;
7233 }
7234
7235 /* We must have run out of tuples */
7237
7238 /* The core code would have registered postmaster death event */
7240
7241 /* Begin an asynchronous data fetch if not already done */
7242 if (!pendingAreq)
7245 {
7246 /*
7247 * This is the case when the in-process request was made by another
7248 * Append. Note that it might be useless to process the request made
7249 * by that Append, because the query might not need tuples from that
7250 * Append anymore; so we avoid processing it to begin a fetch for the
7251 * given request if possible. If there are any child subplans of the
7252 * same parent that are ready for new requests, skip the given
7253 * request. Likewise, if there are any configured events other than
7254 * the postmaster death event, skip it. Otherwise, process the
7255 * in-process request, then begin a fetch to configure the event
7256 * below, because we might otherwise end up with no configured events
7257 * other than the postmaster death event.
7258 */
7260 return;
7262 return;
7263 process_pending_request(pendingAreq);
7265 }
7267 {
7268 /*
7269 * This is the case when the in-process request was made by the same
7270 * parent but for a different child. Since we configure only the
7271 * event for the request made for that child, skip the given request.
7272 */
7273 return;
7274 }
7275 else
7277
7280}
static void fetch_more_data_begin(AsyncRequest *areq)
Definition postgres_fdw.c:7397
static void complete_pending_request(AsyncRequest *areq)
Definition postgres_fdw.c:7457
Definition execnodes.h:1497
Definition execnodes.h:640
Definition waiteventset.c:118
int GetNumRegisteredWaitEvents(WaitEventSet *set)
Definition waiteventset.c:1884
int AddWaitEventToSet(WaitEventSet *set, uint32 events, pgsocket fd, Latch *latch, void *user_data)
Definition waiteventset.c:569
References AddWaitEventToSet(), AppendState::as_eventset, AppendState::as_needrequest, Assert, bms_is_empty, complete_pending_request(), PgFdwScanState::conn, PgFdwScanState::conn_state, fb(), ForeignScanState::fdw_state, fetch_more_data_begin(), GetNumRegisteredWaitEvents(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, PgFdwConnState::pendingAreq, PQsocket(), process_pending_request(), AsyncRequest::requestee, AsyncRequest::requestor, and WL_SOCKET_READABLE.
Referenced by postgres_fdw_handler().
◆ postgresForeignAsyncNotify()
|
static |
Definition at line 7288 of file postgres_fdw.c.
7289{
7292
7293 /* The core code would have initialized the callback_pending flag */
7295
7296 /*
7297 * If process_pending_request() has been invoked on the given request
7298 * before we get here, we might have some tuples already; in which case
7299 * produce the next tuple
7300 */
7302 {
7304 return;
7305 }
7306
7307 /* We must have run out of tuples */
7309
7310 /* The request should be currently in-process */
7312
7313 /* On error, report the original query, not the FETCH. */
7316
7317 fetch_more_data(node);
7318
7320}
References Assert, PgFdwScanState::conn, PgFdwScanState::conn_state, fb(), ForeignScanState::fdw_state, fetch_more_data(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, PgFdwConnState::pendingAreq, pgfdw_report_error(), PQconsumeInput(), produce_tuple_asynchronously(), and PgFdwScanState::query.
Referenced by postgres_fdw_handler().
◆ postgresForeignAsyncRequest()
|
static |
Definition at line 7201 of file postgres_fdw.c.
References fb(), and produce_tuple_asynchronously().
Referenced by postgres_fdw_handler().
◆ postgresGetAnalyzeInfoForForeignTable()
|
static |
Definition at line 4946 of file postgres_fdw.c.
4947{
4951 StringInfoData sql;
4952 PGresult *res;
4953 double reltuples;
4954 char relkind;
4955
4956 /* assume the remote relation does not support TABLESAMPLE */
4958
4959 /*
4960 * Get the connection to use. We do the remote access as the table's
4961 * owner, even if the ANALYZE was started by some other user.
4962 */
4966
4967 /*
4968 * Construct command to get page count for relation.
4969 */
4970 initStringInfo(&sql);
4971 deparseAnalyzeInfoSql(&sql, relation);
4972
4976
4980 relkind = *(PQgetvalue(res, 0, 1));
4981 PQclear(res);
4982
4984
4985 /* TABLESAMPLE is supported only for regular tables and matviews */
4987 relkind == RELKIND_MATVIEW ||
4988 relkind == RELKIND_PARTITIONED_TABLE);
4989
4990 return reltuples;
4991}
void deparseAnalyzeInfoSql(StringInfo buf, Relation rel)
Definition deparse.c:2552
References conn, StringInfoData::data, deparseAnalyzeInfoSql(), elog, ERROR, fb(), GetConnection(), GetForeignTable(), GetUserMapping(), initStringInfo(), pgfdw_exec_query(), pgfdw_report_error(), PGRES_TUPLES_OK, PQclear, PQgetvalue, PQnfields, PQntuples, PQresultStatus, RelationData::rd_rel, RelationGetRelid, ReleaseConnection(), table, and user.
Referenced by postgresAcquireSampleRowsFunc().
◆ postgresGetForeignJoinPaths()
|
static |
Definition at line 6263 of file postgres_fdw.c.
6269{
6272 double rows;
6273 int width;
6274 int disabled_nodes;
6275 Cost startup_cost;
6276 Cost total_cost;
6278 * EvalPlanQual gets triggered. */
6279
6280 /*
6281 * Skip if this join combination has been considered already.
6282 */
6283 if (joinrel->fdw_private)
6284 return;
6285
6286 /*
6287 * This code does not work for joins with lateral references, since those
6288 * must have parameterized paths, which we don't generate yet.
6289 */
6291 return;
6292
6293 /*
6294 * Create unfinished PgFdwRelationInfo entry which is used to indicate
6295 * that the join relation is already considered, so that we won't waste
6296 * time in judging safety of join pushdown and adding the same paths again
6297 * if found safe. Once we know that this join can be pushed down, we fill
6298 * the entry.
6299 */
6302 joinrel->fdw_private = fpinfo;
6303 /* attrs_used is only for base relations. */
6305
6306 /*
6307 * If there is a possibility that EvalPlanQual will be executed, we need
6308 * to be able to reconstruct the row using scans of the base relations.
6309 * GetExistingLocalJoinPath will find a suitable path for this purpose in
6310 * the path list of the joinrel, if one exists. We must be careful to
6311 * call it before adding any ForeignPath, since the ForeignPath might
6312 * dominate the only suitable local path available. We also do it before
6313 * calling foreign_join_ok(), since that function updates fpinfo and marks
6314 * it as pushable if the join is found to be pushable.
6315 */
6318 root->rowMarks)
6319 {
6322 {
6323 elog(DEBUG3, "could not push down foreign join because a local path suitable for EPQ checks was not found");
6324 return;
6325 }
6326 }
6327 else
6329
6331 {
6332 /* Free path required for EPQ if we copied one; we don't need it now */
6335 return;
6336 }
6337
6338 /*
6339 * Compute the selectivity and cost of the local_conds, so we don't have
6340 * to do it over again for each path. The best we can do for these
6341 * conditions is to estimate selectivity on the basis of local statistics.
6342 * The local conditions are applied after the join has been computed on
6343 * the remote side like quals in WHERE clause, so pass jointype as
6344 * JOIN_INNER.
6345 */
6347 fpinfo->local_conds,
6348 0,
6349 JOIN_INNER,
6350 NULL);
6352
6353 /*
6354 * If we are going to estimate costs locally, estimate the join clause
6355 * selectivity here while we have special join info.
6356 */
6359 0, fpinfo->jointype,
6360 extra->sjinfo);
6361
6362 /* Estimate costs for bare join relation */
6364 &rows, &width, &disabled_nodes,
6365 &startup_cost, &total_cost);
6366 /* Now update this information in the joinrel */
6367 joinrel->rows = rows;
6369 fpinfo->rows = rows;
6370 fpinfo->width = width;
6371 fpinfo->disabled_nodes = disabled_nodes;
6372 fpinfo->startup_cost = startup_cost;
6373 fpinfo->total_cost = total_cost;
6374
6375 /*
6376 * Create a new join path and add it to the joinrel which represents a
6377 * join between foreign tables.
6378 */
6380 joinrel,
6382 rows,
6383 disabled_nodes,
6384 startup_cost,
6385 total_cost,
6387 joinrel->lateral_relids,
6388 epq_path,
6389 extra->restrictlist,
6391
6392 /* Add generated path into joinrel by add_path(). */
6394
6395 /* Consider pathkeys for the join relation */
6397 extra->restrictlist);
6398
6399 /* XXX Consider parameterized paths for the join relation */
6400}
Path * GetExistingLocalJoinPath(RelOptInfo *joinrel)
Definition foreign.c:742
static bool foreign_join_ok(PlannerInfo *root, RelOptInfo *joinrel, JoinType jointype, RelOptInfo *outerrel, RelOptInfo *innerrel, JoinPathExtraData *extra)
Definition postgres_fdw.c:5699
static void add_paths_with_pathkeys_for_rel(PlannerInfo *root, RelOptInfo *rel, Path *epq_path, List *restrictlist)
Definition postgres_fdw.c:6020
References add_path(), add_paths_with_pathkeys_for_rel(), bms_is_empty, clauselist_selectivity(), CMD_DELETE, CMD_UPDATE, cost_qual_eval(), create_foreign_join_path(), DEBUG3, elog, estimate_path_cost_size(), fb(), foreign_join_ok(), GetExistingLocalJoinPath(), JOIN_INNER, RelOptInfo::lateral_relids, NIL, palloc0_object, pfree(), RelOptInfo::reltarget, JoinPathExtraData::restrictlist, root, RelOptInfo::rows, JoinPathExtraData::sjinfo, and PathTarget::width.
Referenced by postgres_fdw_handler().
◆ postgresGetForeignModifyBatchSize()
|
static |
Definition at line 2034 of file postgres_fdw.c.
2035{
2036 int batch_size;
2038
2039 /* should be called only once */
2041
2042 /*
2043 * Should never get called when the insert is being performed on a table
2044 * that is also among the target relations of an UPDATE operation, because
2045 * postgresBeginForeignInsert() currently rejects such insert attempts.
2046 */
2048
2049 /*
2050 * In EXPLAIN without ANALYZE, ri_FdwState is NULL, so we have to lookup
2051 * the option directly in server/table options. Otherwise just use the
2052 * value we determined earlier.
2053 */
2055 batch_size = fmstate->batch_size;
2056 else
2058
2059 /*
2060 * Disable batching when we have to use RETURNING, there are any
2061 * BEFORE/AFTER ROW INSERT triggers on the foreign table, or there are any
2062 * WITH CHECK OPTION constraints from parent views.
2063 *
2064 * When there are any BEFORE ROW INSERT triggers on the table, we can't
2065 * support it, because such triggers might query the table we're inserting
2066 * into and act differently if the tuples that have already been processed
2067 * and prepared for insertion are not there.
2068 */
2071 (resultRelInfo->ri_TrigDesc &&
2074 return 1;
2075
2076 /*
2077 * If the foreign table has no columns, disable batching as the INSERT
2078 * syntax doesn't allow batching multiple empty rows into a zero-column
2079 * table in a single statement. This is needed for COPY FROM, in which
2080 * case fmstate must be non-NULL.
2081 */
2083 return 1;
2084
2085 /*
2086 * Otherwise use the batch size specified for server/table. The number of
2087 * parameters in a batch is limited to 65535 (uint16), so make sure we
2088 * don't exceed this limit by using the maximum batch_size possible.
2089 */
2092
2093 return batch_size;
2094}
References Assert, fb(), get_batch_size_option(), list_length(), Min, NIL, PQ_QUERY_PARAM_MAX_LIMIT, ResultRelInfo::ri_BatchSize, ResultRelInfo::ri_FdwState, ResultRelInfo::ri_projectReturning, ResultRelInfo::ri_RelationDesc, ResultRelInfo::ri_TrigDesc, ResultRelInfo::ri_WithCheckOptions, TriggerDesc::trig_insert_after_row, and TriggerDesc::trig_insert_before_row.
Referenced by postgres_fdw_handler().
◆ postgresGetForeignPaths()
|
static |
Definition at line 1016 of file postgres_fdw.c.
1019{
1021 ForeignPath *path;
1024
1025 /*
1026 * Create simplest ForeignScan path node and add it to baserel. This path
1027 * corresponds to SeqScan path of regular tables (though depending on what
1028 * baserestrict conditions we were able to send to remote, there might
1029 * actually be an indexscan happening there). We already did all the work
1030 * to estimate cost and size of this path.
1031 *
1032 * Although this path uses no join clauses, it could still have required
1033 * parameterization due to LATERAL refs in its tlist.
1034 */
1037 fpinfo->rows,
1038 fpinfo->disabled_nodes,
1039 fpinfo->startup_cost,
1040 fpinfo->total_cost,
1042 baserel->lateral_relids,
1047
1048 /* Add paths with pathkeys */
1050
1051 /*
1052 * If we're not using remote estimates, stop here. We have no way to
1053 * estimate whether any join clauses would be worth sending across, so
1054 * don't bother building parameterized paths.
1055 */
1057 return;
1058
1059 /*
1060 * Thumb through all join clauses for the rel to identify which outer
1061 * relations could supply one or more safe-to-send-to-remote join clauses.
1062 * We'll build a parameterized path for each such outer relation.
1063 *
1064 * It's convenient to manage this by representing each candidate outer
1065 * relation by the ParamPathInfo node for it. We can then use the
1066 * ppi_clauses list in the ParamPathInfo node directly as a list of the
1067 * interesting join clauses for that rel. This takes care of the
1068 * possibility that there are multiple safe join clauses for such a rel,
1069 * and also ensures that we account for unsafe join clauses that we'll
1070 * still have to enforce locally (since the parameterized-path machinery
1071 * insists that we handle all movable clauses).
1072 */
1075 {
1079
1080 /* Check if clause can be moved to this rel */
1082 continue;
1083
1084 /* See if it is safe to send to remote */
1086 continue;
1087
1088 /* Calculate required outer rels for the resulting path */
1090 baserel->lateral_relids);
1091 /* We do not want the foreign rel itself listed in required_outer */
1093
1094 /*
1095 * required_outer probably can't be empty here, but if it were, we
1096 * couldn't make a parameterized path.
1097 */
1099 continue;
1100
1101 /* Get the ParamPathInfo */
1103 required_outer);
1105
1106 /*
1107 * Add it to list unless we already have it. Testing pointer equality
1108 * is OK since get_baserel_parampathinfo won't make duplicates.
1109 */
1111 }
1112
1113 /*
1114 * The above scan examined only "generic" join clauses, not those that
1115 * were absorbed into EquivalenceClauses. See if we can make anything out
1116 * of EquivalenceClauses.
1117 */
1119 {
1120 /*
1121 * We repeatedly scan the eclass list looking for column references
1122 * (or expressions) belonging to the foreign rel. Each time we find
1123 * one, we generate a list of equivalence joinclauses for it, and then
1124 * see if any are safe to send to the remote. Repeat till there are
1125 * no more candidate EC members.
1126 */
1128
1130 for (;;)
1131 {
1132 List *clauses;
1133
1134 /* Make clauses, skipping any that join to lateral_referencers */
1137 baserel,
1139 &arg,
1140 baserel->lateral_referencers);
1141
1142 /* Done if there are no more expressions in the foreign rel */
1144 {
1146 break;
1147 }
1148
1149 /* Scan the extracted join clauses */
1151 {
1155
1156 /* Check if clause can be moved to this rel */
1158 continue;
1159
1160 /* See if it is safe to send to remote */
1162 continue;
1163
1164 /* Calculate required outer rels for the resulting path */
1166 baserel->lateral_relids);
1169 continue;
1170
1171 /* Get the ParamPathInfo */
1173 required_outer);
1175
1176 /* Add it to list unless we already have it */
1178 }
1179
1180 /* Try again, now ignoring the expression we found this time */
1182 }
1183 }
1184
1185 /*
1186 * Now build a path for each useful outer relation.
1187 */
1189 {
1191 double rows;
1192 int width;
1193 int disabled_nodes;
1194 Cost startup_cost;
1195 Cost total_cost;
1196
1197 /* Get a cost estimate from the remote */
1200 &rows, &width, &disabled_nodes,
1201 &startup_cost, &total_cost);
1202
1203 /*
1204 * ppi_rows currently won't get looked at by anything, but still we
1205 * may as well ensure that it matches our idea of the rowcount.
1206 */
1207 param_info->ppi_rows = rows;
1208
1209 /* Make the path */
1212 rows,
1213 disabled_nodes,
1214 startup_cost,
1215 total_cost,
1217 param_info->ppi_req_outer,
1218 NULL,
1222 }
1223}
List * generate_implied_equalities_for_column(PlannerInfo *root, RelOptInfo *rel, ec_matches_callback_type callback, void *callback_arg, Relids prohibited_rels)
Definition equivclass.c:3238
static bool ec_member_matches_foreign(PlannerInfo *root, RelOptInfo *rel, EquivalenceClass *ec, EquivalenceMember *em, void *arg)
Definition postgres_fdw.c:3696
ParamPathInfo * get_baserel_parampathinfo(PlannerInfo *root, RelOptInfo *baserel, Relids required_outer)
Definition relnode.c:1693
bool join_clause_is_movable_to(RestrictInfo *rinfo, RelOptInfo *baserel)
Definition restrictinfo.c:575
Definition pathnodes.h:1899
References add_path(), add_paths_with_pathkeys_for_rel(), ec_member_foreign_arg::already_used, arg, Assert, bms_del_member(), bms_is_empty, bms_union(), RestrictInfo::clause, create_foreignscan_path(), ec_member_matches_foreign(), estimate_path_cost_size(), fb(), generate_implied_equalities_for_column(), get_baserel_parampathinfo(), is_foreign_expr(), join_clause_is_movable_to(), lappend(), lfirst, list_append_unique_ptr(), NIL, and root.
Referenced by postgres_fdw_handler().
◆ postgresGetForeignPlan()
|
static |
Definition at line 1230 of file postgres_fdw.c.
1237{
1240 List *fdw_private;
1246 List *retrieved_attrs;
1247 StringInfoData sql;
1248 bool has_final_sort = false;
1249 bool has_limit = false;
1251
1252 /*
1253 * Get FDW private data created by postgresGetForeignUpperPaths(), if any.
1254 */
1256 {
1258 FdwPathPrivateHasFinalSort));
1260 FdwPathPrivateHasLimit));
1261 }
1262
1264 {
1265 /*
1266 * For base relations, set scan_relid as the relid of the relation.
1267 */
1269
1270 /*
1271 * In a base-relation scan, we must apply the given scan_clauses.
1272 *
1273 * Separate the scan_clauses into those that can be executed remotely
1274 * and those that can't. baserestrictinfo clauses that were
1275 * previously determined to be safe or unsafe by classifyConditions
1276 * are found in fpinfo->remote_conds and fpinfo->local_conds. Anything
1277 * else in the scan_clauses list will be a join clause, which we have
1278 * to check for remote-safety.
1279 *
1280 * Note: the join clauses we see here should be the exact same ones
1281 * previously examined by postgresGetForeignPaths. Possibly it'd be
1282 * worth passing forward the classification work done then, rather
1283 * than repeating it here.
1284 *
1285 * This code must match "extract_actual_clauses(scan_clauses, false)"
1286 * except for the additional decision about remote versus local
1287 * execution.
1288 */
1290 {
1292
1293 /* Ignore any pseudoconstants, they're dealt with elsewhere */
1294 if (rinfo->pseudoconstant)
1295 continue;
1296
1303 else
1305 }
1306
1307 /*
1308 * For a base-relation scan, we have to support EPQ recheck, which
1309 * should recheck all the remote quals.
1310 */
1311 fdw_recheck_quals = remote_exprs;
1312 }
1313 else
1314 {
1315 /*
1316 * Join relation or upper relation - set scan_relid to 0.
1317 */
1318 scan_relid = 0;
1319
1320 /*
1321 * For a join rel, baserestrictinfo is NIL and we are not considering
1322 * parameterization right now, so there should be no scan_clauses for
1323 * a joinrel or an upper rel either.
1324 */
1326
1327 /*
1328 * Instead we get the conditions to apply from the fdw_private
1329 * structure.
1330 */
1333
1334 /*
1335 * We leave fdw_recheck_quals empty in this case, since we never need
1336 * to apply EPQ recheck clauses. In the case of a joinrel, EPQ
1337 * recheck is handled elsewhere --- see postgresGetForeignJoinPaths().
1338 * If we're planning an upperrel (ie, remote grouping or aggregation)
1339 * then there's no EPQ to do because SELECT FOR UPDATE wouldn't be
1340 * allowed, and indeed we *can't* put the remote clauses into
1341 * fdw_recheck_quals because the unaggregated Vars won't be available
1342 * locally.
1343 */
1344
1345 /* Build the list of columns to be fetched from the foreign server. */
1346 fdw_scan_tlist = build_tlist_to_deparse(foreignrel);
1347
1348 /*
1349 * Ensure that the outer plan produces a tuple whose descriptor
1350 * matches our scan tuple slot. Also, remove the local conditions
1351 * from outer plan's quals, lest they be evaluated twice, once by the
1352 * local plan and once by the scan.
1353 */
1354 if (outer_plan)
1355 {
1356 /*
1357 * Right now, we only consider grouping and aggregation beyond
1358 * joins. Queries involving aggregates or grouping do not require
1359 * EPQ mechanism, hence should not have an outer plan here.
1360 */
1362
1363 /*
1364 * First, update the plan's qual list if possible. In some cases
1365 * the quals might be enforced below the topmost plan level, in
1366 * which case we'll fail to remove them; it's not worth working
1367 * harder than this.
1368 */
1370 {
1372
1374
1375 /*
1376 * For an inner join the local conditions of foreign scan plan
1377 * can be part of the joinquals as well. (They might also be
1378 * in the mergequals or hashquals, but we can't touch those
1379 * without breaking the plan.)
1380 */
1384 {
1386
1389 qual);
1390 }
1391 }
1392
1393 /*
1394 * Now fix the subplan's tlist --- this might result in inserting
1395 * a Result node atop the plan tree.
1396 */
1397 outer_plan = change_plan_targetlist(outer_plan, fdw_scan_tlist,
1398 best_path->path.parallel_safe);
1399 }
1400 }
1401
1402 /*
1403 * Build the query string to be sent for execution, and identify
1404 * expressions to be sent as parameters.
1405 */
1406 initStringInfo(&sql);
1409 has_final_sort, has_limit, false,
1410 &retrieved_attrs, ¶ms_list);
1411
1412 /* Remember remote_exprs for possible use by postgresPlanDirectModify */
1414
1415 /*
1416 * Build the fdw_private list that will be available to the executor.
1417 * Items in the list must match order in enum FdwScanPrivateIndex.
1418 */
1420 retrieved_attrs,
1423 fdw_private = lappend(fdw_private,
1425
1426 /*
1427 * Create the ForeignScan node for the given relation.
1428 *
1429 * Note that the remote parameter expressions are stored in the fdw_exprs
1430 * field of the finished plan node; we can't keep them in private state
1431 * because then they wouldn't be subject to later planner processing.
1432 */
1434 local_exprs,
1435 scan_relid,
1436 params_list,
1437 fdw_private,
1438 fdw_scan_tlist,
1439 fdw_recheck_quals,
1440 outer_plan);
1441}
ForeignScan * make_foreignscan(List *qptlist, List *qpqual, Index scanrelid, List *fdw_exprs, List *fdw_private, List *fdw_scan_tlist, List *fdw_recheck_quals, Plan *outer_plan)
Definition createplan.c:5799
Plan * change_plan_targetlist(Plan *subplan, List *tlist, bool tlist_parallel_safe)
Definition createplan.c:1989
List * extract_actual_clauses(List *restrictinfo_list, bool pseudoconstant)
Definition restrictinfo.c:485
Definition plannodes.h:1044
Definition plannodes.h:964
Definition plannodes.h:1015
Definition plannodes.h:986
References Assert, boolVal, build_tlist_to_deparse(), change_plan_targetlist(), RestrictInfo::clause, StringInfoData::data, deparseSelectStmtForRel(), extract_actual_clauses(), fb(), FdwPathPrivateHasFinalSort, FdwPathPrivateHasLimit, initStringInfo(), is_foreign_expr(), IS_JOIN_REL, IS_SIMPLE_REL, IS_UPPER_REL, IsA, JOIN_INNER, lappend(), lfirst, lfirst_node, list_delete(), list_make3, list_member_ptr(), list_nth(), make_foreignscan(), makeInteger(), makeString(), NIL, Plan::qual, RelOptInfo::relid, and root.
Referenced by postgres_fdw_handler().
◆ postgresGetForeignRelSize()
|
static |
Definition at line 625 of file postgres_fdw.c.
628{
631
632 /*
633 * We use PgFdwRelationInfo to pass various information to subsequent
634 * functions.
635 */
638
639 /* Base foreign tables need to be pushed down always. */
641
642 /* Look up foreign-table catalog info. */
645
646 /*
647 * Extract user-settable option values. Note that per-table settings of
648 * use_remote_estimate, fetch_size and async_capable override per-server
649 * settings of them, respectively.
650 */
655 fpinfo->fetch_size = 100;
657
660
661 /*
662 * If the table or the server is configured to use remote estimates,
663 * identify which user to do remote access as during planning. This
664 * should match what ExecCheckPermissions() does. If we fail due to lack
665 * of permissions, the query would have failed at runtime anyway.
666 */
668 {
669 Oid userid;
670
673 }
674 else
676
677 /*
678 * Identify which baserestrictinfo clauses can be sent to the remote
679 * server and which can't.
680 */
683
684 /*
685 * Identify which attributes will need to be retrieved from the remote
686 * server. These include all attrs needed for joins or final output, plus
687 * all attrs used in the local_conds. (Note: if we end up using a
688 * parameterized scan, it's possible that some of the join clauses will be
689 * sent to the remote and thus we wouldn't really need to retrieve the
690 * columns used in them. Doesn't seem worth detecting that case though.)
691 */
694 &fpinfo->attrs_used);
696 {
698
700 &fpinfo->attrs_used);
701 }
702
703 /*
704 * Compute the selectivity and cost of the local_conds, so we don't have
705 * to do it over again for each path. The best we can do for these
706 * conditions is to estimate selectivity on the basis of local statistics.
707 */
709 fpinfo->local_conds,
710 baserel->relid,
711 JOIN_INNER,
712 NULL);
713
715
716 /*
717 * Set # of retrieved rows and cached relation costs to some negative
718 * value, so that we can detect when they are set to some sensible values,
719 * during one (usually the first) of the calls to estimate_path_cost_size.
720 */
721 fpinfo->retrieved_rows = -1;
722 fpinfo->rel_startup_cost = -1;
723 fpinfo->rel_total_cost = -1;
724
725 /*
726 * If the table or the server is configured to use remote estimates,
727 * connect to the foreign server and execute EXPLAIN to estimate the
728 * number of rows selected by the restriction clauses, as well as the
729 * average row width. Otherwise, estimate using whatever statistics we
730 * have locally, in a way similar to ordinary tables.
731 */
733 {
734 /*
735 * Get cost/size estimates with help of remote server. Save the
736 * values in fpinfo so we don't need to do it again to generate the
737 * basic foreign path.
738 */
741 &fpinfo->disabled_nodes,
743
744 /* Report estimated baserel size to planner. */
747 }
748 else
749 {
750 /*
751 * If the foreign table has never been ANALYZEd, it will have
752 * reltuples < 0, meaning "unknown". We can't do much if we're not
753 * allowed to consult the remote server, but we can use a hack similar
754 * to plancat.c's treatment of empty relations: use a minimum size
755 * estimate of 10 pages, and divide by the column-datatype-based width
756 * estimate to get the corresponding number of tuples.
757 */
759 {
760 baserel->pages = 10;
761 baserel->tuples =
764 }
765
766 /* Estimate baserel size as best we can with local statistics. */
768
769 /* Fill in basically-bogus cost estimates for use later. */
772 &fpinfo->disabled_nodes,
774 }
775
776 /*
777 * fpinfo->relation_name gets the numeric rangetable index of the foreign
778 * table RTE. (If this query gets EXPLAIN'd, we'll convert that to a
779 * human-readable string at that time.)
780 */
782
783 /* No outer and inner relations. */
788 /* Set the relation index. */
790}
void set_baserel_size_estimates(PlannerInfo *root, RelOptInfo *rel)
Definition costsize.c:5496
static void apply_server_options(PgFdwRelationInfo *fpinfo)
Definition postgres_fdw.c:6143
static void apply_table_options(PgFdwRelationInfo *fpinfo)
Definition postgres_fdw.c:6175
void pull_varattnos(Node *node, Index varno, Bitmapset **varattnos)
Definition var.c:296
References apply_server_options(), apply_table_options(), classifyConditions(), RestrictInfo::clause, clauselist_selectivity(), cost_qual_eval(), DEFAULT_FDW_STARTUP_COST, DEFAULT_FDW_TUPLE_COST, estimate_path_cost_size(), fb(), GetForeignServer(), GetForeignTable(), GetUserId(), GetUserMapping(), JOIN_INNER, lfirst_node, MAXALIGN, NIL, OidIsValid, palloc0_object, psprintf(), pull_varattnos(), root, set_baserel_size_estimates(), and SizeofHeapTupleHeader.
Referenced by postgres_fdw_handler().
◆ postgresGetForeignUpperPaths()
|
static |
Definition at line 6648 of file postgres_fdw.c.
6651{
6653
6654 /*
6655 * If input rel is not safe to pushdown, then simply return as we cannot
6656 * perform any post-join operations on the foreign server.
6657 */
6660 return;
6661
6662 /* Ignore stages we don't support; and skip any duplicate calls. */
6664 stage != UPPERREL_ORDERED &&
6665 stage != UPPERREL_FINAL) ||
6666 output_rel->fdw_private)
6667 return;
6668
6671 fpinfo->stage = stage;
6673
6674 switch (stage)
6675 {
6678 (GroupPathExtraData *) extra);
6679 break;
6682 break;
6685 (FinalPathExtraData *) extra);
6686 break;
6687 default:
6689 break;
6690 }
6691}
static void add_foreign_grouping_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *grouped_rel, GroupPathExtraData *extra)
Definition postgres_fdw.c:6701
static void add_foreign_ordered_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *ordered_rel)
Definition postgres_fdw.c:6797
static void add_foreign_final_paths(PlannerInfo *root, RelOptInfo *input_rel, RelOptInfo *final_rel, FinalPathExtraData *extra)
Definition postgres_fdw.c:6935
Definition pathnodes.h:3660
Definition pathnodes.h:3635
References add_foreign_final_paths(), add_foreign_grouping_paths(), add_foreign_ordered_paths(), elog, ERROR, fb(), palloc0_object, root, UPPERREL_FINAL, UPPERREL_GROUP_AGG, and UPPERREL_ORDERED.
Referenced by postgres_fdw_handler().
◆ postgresImportForeignSchema()
|
static |
Definition at line 5373 of file postgres_fdw.c.
5374{
5380 ForeignServer *server;
5384 PGresult *res;
5385 int numrows,
5386 i;
5388
5389 /* Parse statement options */
5391 {
5393
5402 else
5406 }
5407
5408 /*
5409 * Get connection to the foreign server. Connection manager will
5410 * establish new connection if necessary.
5411 */
5415
5416 /* Don't attempt to import collation if remote server hasn't got it */
5419
5420 /* Create workspace for strings */
5422
5423 /* Check that the schema really exists */
5426
5430
5436
5437 PQclear(res);
5439
5440 /*
5441 * Fetch all table data from this schema, possibly restricted by EXCEPT or
5442 * LIMIT TO. (We don't actually need to pay any attention to EXCEPT/LIMIT
5443 * TO here, because the core code will filter the statements we return
5444 * according to those lists anyway. But it should save a few cycles to
5445 * not process excluded tables in the first place.)
5446 *
5447 * Import table data for partitions only when they are explicitly
5448 * specified in LIMIT TO clause. Otherwise ignore them and only include
5449 * the definitions of the root partitioned tables to allow access to the
5450 * complete remote data set locally in the schema imported.
5451 *
5452 * Note: because we run the connection with search_path restricted to
5453 * pg_catalog, the format_type() and pg_get_expr() outputs will always
5454 * include a schema name for types/functions in other schemas, which is
5455 * what we want.
5456 */
5458 "SELECT relname, "
5459 " attname, "
5460 " format_type(atttypid, atttypmod), "
5461 " attnotnull, "
5462 " pg_get_expr(adbin, adrelid), ");
5463
5464 /* Generated columns are supported since Postgres 12 */
5467 " attgenerated, ");
5468 else
5470 " NULL, ");
5471
5474 " collname, "
5475 " collnsp.nspname ");
5476 else
5478 " NULL, NULL ");
5479
5481 "FROM pg_class c "
5482 " JOIN pg_namespace n ON "
5483 " relnamespace = n.oid "
5484 " LEFT JOIN pg_attribute a ON "
5485 " attrelid = c.oid AND attnum > 0 "
5486 " AND NOT attisdropped "
5487 " LEFT JOIN pg_attrdef ad ON "
5488 " adrelid = c.oid AND adnum = attnum ");
5489
5492 " LEFT JOIN pg_collation coll ON "
5493 " coll.oid = attcollation "
5494 " LEFT JOIN pg_namespace collnsp ON "
5495 " collnsp.oid = collnamespace ");
5496
5498 "WHERE c.relkind IN ("
5504 " AND n.nspname = ");
5506
5507 /* Partitions are supported since Postgres 10 */
5511
5512 /* Apply restrictions for LIMIT TO and EXCEPT */
5515 {
5516 bool first_item = true;
5517
5522
5523 /* Append list of table names within IN clause */
5525 {
5527
5528 if (first_item)
5529 first_item = false;
5530 else
5533 }
5535 }
5536
5537 /* Append ORDER BY at the end of query to ensure output ordering */
5539
5540 /* Fetch the data */
5544
5545 /* Process results */
5546 numrows = PQntuples(res);
5547 /* note: incrementation of i happens in inner loop's while() test */
5549 {
5551 bool first_item = true;
5552
5555 quote_identifier(tablename));
5556
5557 /* Scan all rows for this table */
5558 do
5559 {
5561 char *typename;
5563 char *attgenerated;
5565 char *collname;
5567
5568 /* If table has no columns, we'll see nulls here */
5570 continue;
5571
5583
5584 if (first_item)
5585 first_item = false;
5586 else
5588
5589 /* Print column name and type */
5592 typename);
5593
5594 /*
5595 * Add column_name option so that renaming the foreign table's
5596 * column doesn't break the association to the underlying column.
5597 */
5601
5602 /* Add COLLATE if needed */
5606 quote_identifier(collname));
5607
5608 /* Add DEFAULT if needed */
5610 (!attgenerated || !attgenerated[0]))
5612
5613 /* Add GENERATED if needed */
5615 attgenerated[0] == ATTRIBUTE_GENERATED_STORED)
5616 {
5619 " GENERATED ALWAYS AS (%s) STORED",
5620 attdefault);
5621 }
5622
5623 /* Add NOT NULL if needed */
5626 }
5629
5630 /*
5631 * Add server name and table-level options. We specify remote schema
5632 * and table name as options (the latter to ensure that renaming the
5633 * foreign table doesn't break the association).
5634 */
5637
5642
5644
5646 }
5647 PQclear(res);
5648
5650
5651 return commands;
5652}
void deparseStringLiteral(StringInfo buf, const char *val)
Definition deparse.c:2880
Definition primnodes.h:73
References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attname, attnotnull, buf, conn, CppAsString2, defGetBoolean(), DefElem::defname, deparseStringLiteral(), ereport, errcode(), errmsg(), ERROR, fb(), FDW_IMPORT_SCHEMA_EXCEPT, FDW_IMPORT_SCHEMA_LIMIT_TO, GetConnection(), GetForeignServer(), GetUserId(), GetUserMapping(), i, initStringInfo(), lappend(), lfirst, NIL, pgfdw_exec_query(), pgfdw_report_error(), PGRES_TUPLES_OK, PQclear, PQgetisnull, PQgetvalue, PQntuples, PQresultStatus, PQserverVersion(), pstrdup(), quote_identifier(), ReleaseConnection(), RangeVar::relname, resetStringInfo(), ForeignServer::serverid, ForeignServer::servername, and stmt.
Referenced by postgres_fdw_handler().
◆ postgresIsForeignPathAsyncCapable()
|
static |
Definition at line 7188 of file postgres_fdw.c.
7189{
7192
7194}
References fb().
Referenced by postgres_fdw_handler().
◆ postgresIsForeignRelUpdatable()
Definition at line 2312 of file postgres_fdw.c.
2313{
2314 bool updatable;
2316 ForeignServer *server;
2318
2319 /*
2320 * By default, all postgres_fdw foreign tables are assumed updatable. This
2321 * can be overridden by a per-server setting, which in turn can be
2322 * overridden by a per-table setting.
2323 */
2324 updatable = true;
2325
2328
2330 {
2332
2334 updatable = defGetBoolean(def);
2335 }
2337 {
2339
2341 updatable = defGetBoolean(def);
2342 }
2343
2344 /*
2345 * Currently "updatable" means support for INSERT, UPDATE and DELETE.
2346 */
2347 return updatable ?
2349}
References CMD_DELETE, CMD_INSERT, CMD_UPDATE, defGetBoolean(), DefElem::defname, fb(), GetForeignServer(), GetForeignTable(), lfirst, ForeignServer::options, RelationGetRelid, and table.
Referenced by postgres_fdw_handler().
◆ postgresIterateDirectModify()
|
static |
Definition at line 2763 of file postgres_fdw.c.
2764{
2768
2769 /*
2770 * If this is the first call after Begin, execute the statement.
2771 */
2773 execute_dml_stmt(node);
2774
2775 /*
2776 * If the local query doesn't specify RETURNING, just clear tuple slot.
2777 */
2779 {
2782
2784
2785 /* Increment the command es_processed count if necessary. */
2788
2789 /* Increment the tuple count for EXPLAIN ANALYZE if necessary. */
2790 if (instr)
2792
2794 }
2795
2796 /*
2797 * Get the next RETURNING tuple.
2798 */
2800}
static TupleTableSlot * get_returning_data(ForeignScanState *node)
Definition postgres_fdw.c:4573
Definition instrument.h:71
References Assert, EState::es_processed, ExecClearTuple(), execute_dml_stmt(), fb(), ForeignScanState::fdw_state, get_returning_data(), PlanState::instrument, ScanState::ps, ForeignScanState::resultRelInfo, ResultRelInfo::ri_projectReturning, ForeignScanState::ss, ScanState::ss_ScanTupleSlot, PlanState::state, and Instrumentation::tuplecount.
Referenced by postgres_fdw_handler().
◆ postgresIterateForeignScan()
|
static |
Definition at line 1604 of file postgres_fdw.c.
1605{
1608
1609 /*
1610 * In sync mode, if this is the first call after Begin or ReScan, we need
1611 * to create the cursor on the remote side. In async mode, we would have
1612 * already created the cursor before we get here, even if this is the
1613 * first call after Begin or ReScan.
1614 */
1615 if (!fsstate->cursor_exists)
1616 create_cursor(node);
1617
1618 /*
1619 * Get some more tuples, if we've run out.
1620 */
1621 if (fsstate->next_tuple >= fsstate->num_tuples)
1622 {
1623 /* In async mode, just clear tuple slot. */
1624 if (fsstate->async_capable)
1626 /* No point in another fetch if we already detected EOF, though. */
1627 if (!fsstate->eof_reached)
1628 fetch_more_data(node);
1629 /* If we didn't get any tuples, must be end of data. */
1630 if (fsstate->next_tuple >= fsstate->num_tuples)
1632 }
1633
1634 /*
1635 * Return the next tuple.
1636 */
1637 ExecStoreHeapTuple(fsstate->tuples[fsstate->next_tuple++],
1638 slot,
1639 false);
1640
1641 return slot;
1642}
References PgFdwScanState::async_capable, create_cursor(), PgFdwScanState::cursor_exists, PgFdwScanState::eof_reached, ExecClearTuple(), ExecStoreHeapTuple(), ForeignScanState::fdw_state, fetch_more_data(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, ForeignScanState::ss, ScanState::ss_ScanTupleSlot, and PgFdwScanState::tuples.
Referenced by postgres_fdw_handler().
◆ postgresPlanDirectModify()
|
static |
Definition at line 2448 of file postgres_fdw.c.
2452{
2454 RelOptInfo *foreignrel;
2457 Relation rel;
2458 StringInfoData sql;
2466
2467 /*
2468 * Decide whether it is safe to modify a foreign table directly.
2469 */
2470
2471 /*
2472 * The table modification must be an UPDATE or DELETE.
2473 */
2475 return false;
2476
2477 /*
2478 * Try to locate the ForeignScan subplan that's scanning resultRelation.
2479 */
2482 return false;
2483
2484 /*
2485 * It's unsafe to modify a foreign table directly if there are any quals
2486 * that should be evaluated locally.
2487 */
2489 return false;
2490
2491 /* Safe to fetch data about the target foreign rel */
2493 {
2495 /* We should have a rel for this foreign join. */
2496 Assert(foreignrel);
2497 }
2498 else
2499 foreignrel = root->simple_rel_array[resultRelation];
2502
2503 /*
2504 * It's unsafe to update a foreign table directly, if any expressions to
2505 * assign to the target columns are unsafe to evaluate remotely.
2506 */
2508 {
2510 *lc2;
2511
2512 /*
2513 * The expressions of concern are the first N columns of the processed
2514 * targetlist, where N is the length of the rel's update_colnos.
2515 */
2517 &processed_tlist, &targetAttrs);
2519 {
2522
2523 /* update's new-value expressions shouldn't be resjunk */
2525
2528
2530 return false;
2531 }
2532 }
2533
2534 /*
2535 * Ok, rewrite subplan so as to modify the foreign table directly.
2536 */
2537 initStringInfo(&sql);
2538
2539 /*
2540 * Core code already has some lock on each rel being planned, so we can
2541 * use NoLock here.
2542 */
2544
2545 /*
2546 * Recall the qual clauses that must be evaluated remotely. (These are
2547 * bare clauses not RestrictInfos, but deparse.c's appendConditions()
2548 * doesn't care.)
2549 */
2551
2552 /*
2553 * Extract the relevant RETURNING list if any.
2554 */
2556 {
2558
2559 /*
2560 * When performing an UPDATE/DELETE .. RETURNING on a join directly,
2561 * we fetch from the foreign server any Vars specified in RETURNING
2562 * that refer not only to the target relation but to non-target
2563 * relations. So we'll deparse them into the RETURNING clause of the
2564 * remote query; use a targetlist consisting of them instead, which
2565 * will be adjusted to be new fdw_scan_tlist of the foreign-scan plan
2566 * node below.
2567 */
2569 returningList = build_remote_returning(resultRelation, rel,
2570 returningList);
2571 }
2572
2573 /*
2574 * Construct the SQL command string.
2575 */
2576 switch (operation)
2577 {
2580 foreignrel,
2581 processed_tlist,
2582 targetAttrs,
2583 remote_exprs, ¶ms_list,
2584 returningList, &retrieved_attrs);
2585 break;
2588 foreignrel,
2589 remote_exprs, ¶ms_list,
2590 returningList, &retrieved_attrs);
2591 break;
2592 default:
2594 break;
2595 }
2596
2597 /*
2598 * Update the operation and target relation info.
2599 */
2600 fscan->operation = operation;
2601 fscan->resultRelation = resultRelation;
2602
2603 /*
2604 * Update the fdw_exprs list that will be available to the executor.
2605 */
2606 fscan->fdw_exprs = params_list;
2607
2608 /*
2609 * Update the fdw_private list that will be available to the executor.
2610 * Items in the list must match enum FdwDirectModifyPrivateIndex, above.
2611 */
2614 retrieved_attrs,
2616
2617 /*
2618 * Update the foreign-join-related fields.
2619 */
2621 {
2622 /* No need for the outer subplan. */
2624
2625 /* Build new fdw_scan_tlist if UPDATE/DELETE .. RETURNING. */
2626 if (returningList)
2628 }
2629
2630 /*
2631 * Finally, unset the async-capable flag if it is set, as we currently
2632 * don't support asynchronous execution of direct modifications.
2633 */
2636
2638 return true;
2639}
void get_translated_update_targetlist(PlannerInfo *root, Index relid, List **processed_tlist, List **update_colnos)
Definition appendinfo.c:761
void deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root, Index rtindex, Relation rel, RelOptInfo *foreignrel, List *remote_conds, List **params_list, List *returningList, List **retrieved_attrs)
Definition deparse.c:2422
void deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root, Index rtindex, Relation rel, RelOptInfo *foreignrel, List *targetlist, List *targetAttrs, List *remote_conds, List **params_list, List *returningList, List **retrieved_attrs)
Definition deparse.c:2307
static void rebuild_fdw_scan_tlist(ForeignScan *fscan, List *tlist)
Definition postgres_fdw.c:4489
static ForeignScan * find_modifytable_subplan(PlannerInfo *root, ModifyTable *plan, Index rtindex, int subplan_index)
Definition postgres_fdw.c:2388
static List * build_remote_returning(Index rtindex, Relation rel, List *returningList)
Definition postgres_fdw.c:4388
References Assert, build_remote_returning(), CMD_DELETE, CMD_UPDATE, StringInfoData::data, deparseDirectDeleteSql(), deparseDirectUpdateSql(), elog, ERROR, fb(), find_join_rel(), find_modifytable_subplan(), forboth, get_translated_update_targetlist(), initStringInfo(), InvalidAttrNumber, is_foreign_expr(), lfirst_int, lfirst_node, list_make4, list_nth(), makeBoolean(), makeString(), NIL, NoLock, plan, rebuild_fdw_scan_tlist(), root, table_close(), and table_open().
Referenced by postgres_fdw_handler().
◆ postgresPlanForeignModify()
|
static |
Definition at line 1776 of file postgres_fdw.c.
1780{
1783 Relation rel;
1784 StringInfoData sql;
1791
1792 initStringInfo(&sql);
1793
1794 /*
1795 * Core code already has some lock on each rel being planned, so we can
1796 * use NoLock here.
1797 */
1799
1800 /*
1801 * In an INSERT, we transmit all columns that are defined in the foreign
1802 * table. In an UPDATE, if there are BEFORE ROW UPDATE triggers on the
1803 * foreign table, we transmit all columns like INSERT; else we transmit
1804 * only columns that were explicitly targets of the UPDATE, so as to avoid
1805 * unnecessary data transmission. (We can't do that for INSERT since we
1806 * would miss sending default values for columns not listed in the source
1807 * statement, and for UPDATE if there are BEFORE ROW UPDATE triggers since
1808 * those triggers might change values for non-target columns, in which
1809 * case we would miss sending changed values for those columns.)
1810 */
1812 (operation == CMD_UPDATE &&
1813 rel->trigdesc &&
1815 {
1818
1820 {
1822
1825 }
1826 }
1828 {
1832
1833 col = -1;
1835 {
1836 /* bit numbers are offset by FirstLowInvalidHeapAttributeNumber */
1838
1842 }
1843 }
1844
1845 /*
1846 * Extract the relevant WITH CHECK OPTION list if any.
1847 */
1850 subplan_index);
1851
1852 /*
1853 * Extract the relevant RETURNING list if any.
1854 */
1857
1858 /*
1859 * ON CONFLICT DO UPDATE and DO NOTHING case with inference specification
1860 * should have already been rejected in the optimizer, as presently there
1861 * is no way to recognize an arbiter index on a foreign table. Only DO
1862 * NOTHING is supported without an inference specification.
1863 */
1869
1870 /*
1871 * Construct the SQL command string.
1872 */
1873 switch (operation)
1874 {
1878 withCheckOptionList, returningList,
1879 &retrieved_attrs, &values_end_len);
1880 break;
1883 targetAttrs,
1884 withCheckOptionList, returningList,
1885 &retrieved_attrs);
1886 break;
1889 returningList,
1890 &retrieved_attrs);
1891 break;
1892 default:
1894 break;
1895 }
1896
1898
1899 /*
1900 * Build the fdw_private list that will be available to the executor.
1901 * Items in the list must match enum FdwModifyPrivateIndex, above.
1902 */
1904 targetAttrs,
1907 retrieved_attrs);
1908}
void deparseUpdateSql(StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, List *targetAttrs, List *withCheckOptionList, List *returningList, List **retrieved_attrs)
Definition deparse.c:2247
void deparseDeleteSql(StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, List *returningList, List **retrieved_attrs)
Definition deparse.c:2393
Bitmapset * get_rel_all_updated_cols(PlannerInfo *root, RelOptInfo *rel)
Definition inherit.c:652
References CompactAttribute::attisdropped, attnum, bms_next_member(), CMD_DELETE, CMD_INSERT, CMD_UPDATE, StringInfoData::data, deparseDeleteSql(), deparseInsertSql(), deparseUpdateSql(), elog, ERROR, fb(), find_base_rel(), FirstLowInvalidHeapAttributeNumber, get_rel_all_updated_cols(), initStringInfo(), InvalidAttrNumber, lappend_int(), list_make5, list_nth(), makeBoolean(), makeInteger(), makeString(), TupleDescData::natts, NIL, NoLock, ONCONFLICT_NONE, ONCONFLICT_NOTHING, plan, planner_rt_fetch, RelationGetDescr, root, table_close(), table_open(), TriggerDesc::trig_update_before_row, RelationData::trigdesc, and TupleDescCompactAttr().
Referenced by postgres_fdw_handler().
◆ postgresRecheckForeignScan()
|
static |
Definition at line 2356 of file postgres_fdw.c.
2357{
2360 TupleTableSlot *result;
2361
2362 /* For base foreign relations, it suffices to set fdw_recheck_quals */
2363 if (scanrelid > 0)
2364 return true;
2365
2367
2368 /* Execute a local join execution plan */
2371 return false;
2372
2373 /* Store result in the given slot */
2374 ExecCopySlot(slot, result);
2375
2376 return true;
2377}
Definition plannodes.h:518
static TupleTableSlot * ExecCopySlot(TupleTableSlot *dstslot, TupleTableSlot *srcslot)
Definition tuptable.h:524
References Assert, ExecCopySlot(), ExecProcNode(), fb(), outerPlan, outerPlanState, PlanState::plan, ScanState::ps, ForeignScanState::ss, and TupIsNull.
Referenced by postgres_fdw_handler().
◆ postgresReScanForeignScan()
|
static |
Definition at line 1649 of file postgres_fdw.c.
1650{
1652 char sql[64];
1653 PGresult *res;
1654
1655 /* If we haven't created the cursor yet, nothing to do. */
1656 if (!fsstate->cursor_exists)
1657 return;
1658
1659 /*
1660 * If the node is async-capable, and an asynchronous fetch for it has
1661 * begun, the asynchronous fetch might not have yet completed. Check if
1662 * the node is async-capable, and an asynchronous fetch for it is still in
1663 * progress; if so, complete the asynchronous fetch before restarting the
1664 * scan.
1665 */
1666 if (fsstate->async_capable &&
1667 fsstate->conn_state->pendingAreq &&
1668 fsstate->conn_state->pendingAreq->requestee == (PlanState *) node)
1669 fetch_more_data(node);
1670
1671 /*
1672 * If any internal parameters affecting this node have changed, we'd
1673 * better destroy and recreate the cursor. Otherwise, if the remote
1674 * server is v14 or older, rewinding it should be good enough; if not,
1675 * rewind is only allowed for scrollable cursors, but we don't have a way
1676 * to check the scrollability of it, so destroy and recreate it in any
1677 * case. If we've only fetched zero or one batch, we needn't even rewind
1678 * the cursor, just rescan what we have.
1679 */
1681 {
1682 fsstate->cursor_exists = false;
1684 fsstate->cursor_number);
1685 }
1686 else if (fsstate->fetch_ct_2 > 1)
1687 {
1690 fsstate->cursor_number);
1691 else
1692 {
1693 fsstate->cursor_exists = false;
1695 fsstate->cursor_number);
1696 }
1697 }
1698 else
1699 {
1700 /* Easy: just rescan what we already have in memory, if anything */
1701 fsstate->next_tuple = 0;
1702 return;
1703 }
1704
1705 res = pgfdw_exec_query(fsstate->conn, sql, fsstate->conn_state);
1707 pgfdw_report_error(res, fsstate->conn, sql);
1708 PQclear(res);
1709
1710 /* Now force a fresh FETCH. */
1711 fsstate->tuples = NULL;
1712 fsstate->num_tuples = 0;
1713 fsstate->next_tuple = 0;
1714 fsstate->fetch_ct_2 = 0;
1715 fsstate->eof_reached = false;
1716}
References PgFdwScanState::async_capable, PlanState::chgParam, PgFdwScanState::conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_exists, PgFdwScanState::cursor_number, PgFdwScanState::eof_reached, fb(), ForeignScanState::fdw_state, PgFdwScanState::fetch_ct_2, fetch_more_data(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, PgFdwConnState::pendingAreq, pgfdw_exec_query(), pgfdw_report_error(), PGRES_COMMAND_OK, PQclear, PQresultStatus, PQserverVersion(), ScanState::ps, AsyncRequest::requestee, snprintf, ForeignScanState::ss, and PgFdwScanState::tuples.
Referenced by postgres_fdw_handler().
◆ prepare_foreign_modify()
|
static |
Definition at line 4194 of file postgres_fdw.c.
4195{
4197 char *p_name;
4198 PGresult *res;
4199
4200 /*
4201 * The caller would already have processed a pending asynchronous request
4202 * if any, so no need to do it here.
4203 */
4204
4205 /* Construct name we'll use for the prepared statement. */
4209
4210 /*
4211 * We intentionally do not specify parameter types here, but leave the
4212 * remote server to derive them by default. This avoids possible problems
4213 * with the remote server using different type OIDs than we do. All of
4214 * the prepared statements we use in this module are simple enough that
4215 * the remote server will make the right choices.
4216 */
4218 p_name,
4219 fmstate->query,
4220 0,
4221 NULL))
4223
4224 /*
4225 * Get the result, and check for success.
4226 */
4230 PQclear(res);
4231
4232 /* This action shows that the prepare has been done. */
4233 fmstate->p_name = p_name;
4234}
int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes)
Definition fe-exec.c:1553
References fb(), GetPrepStmtNumber(), NAMEDATALEN, pgfdw_get_result(), pgfdw_report_error(), PGRES_COMMAND_OK, PQclear, PQresultStatus, PQsendPrepare(), pstrdup(), and snprintf.
Referenced by execute_foreign_modify().
◆ prepare_query_params()
|
static |
Definition at line 4804 of file postgres_fdw.c.
4810{
4813
4814 Assert(numParams > 0);
4815
4816 /* Prepare for output conversion of parameters used in remote query. */
4818
4819 i = 0;
4821 {
4825
4828 i++;
4829 }
4830
4831 /*
4832 * Prepare remote-parameter expressions for evaluation. (Note: in
4833 * practice, we expect that all these expressions will be just Params, so
4834 * we could possibly do something more efficient than using the full
4835 * expression-eval machinery for this. But probably there would be little
4836 * benefit, and it'd require postgres_fdw to know more than is desirable
4837 * about Param evaluation.)
4838 */
4839 *param_exprs = ExecInitExprList(fdw_exprs, node);
4840
4841 /* Allocate buffer for text form of query parameters. */
4843}
References Assert, ExecInitExprList(), exprType(), fb(), fmgr_info(), getTypeOutputInfo(), i, lfirst, palloc0(), and palloc0_array.
Referenced by postgresBeginDirectModify(), and postgresBeginForeignScan().
◆ process_pending_request()
| void process_pending_request | ( | AsyncRequest * | areq | ) |
Definition at line 7424 of file postgres_fdw.c.
7425{
7428
7429 /* The request would have been pending for a callback */
7431
7432 /* The request should be currently in-process */
7434
7435 fetch_more_data(node);
7436
7437 /*
7438 * If we didn't get any tuples, must be end of data; complete the request
7439 * now. Otherwise, we postpone completing the request until we are called
7440 * from postgresForeignAsyncConfigureWait()/postgresForeignAsyncNotify().
7441 */
7443 {
7444 /* Unlike AsyncNotify, we unset callback_pending ourselves */
7446 /* Mark the request as complete */
7448 /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
7450 }
7451}
void ExecAsyncRequestDone(AsyncRequest *areq, TupleTableSlot *result)
Definition execAsync.c:137
References Assert, PgFdwScanState::conn_state, ExecAsyncRequestDone(), ExecAsyncResponse(), fb(), ForeignScanState::fdw_state, fetch_more_data(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, and PgFdwConnState::pendingAreq.
Referenced by create_cursor(), execute_dml_stmt(), execute_foreign_modify(), GetConnection(), pgfdw_exec_query(), and postgresForeignAsyncConfigureWait().
◆ process_query_params()
|
static |
Definition at line 4849 of file postgres_fdw.c.
4853{
4857
4859
4860 i = 0;
4862 {
4865 bool isNull;
4866
4867 /* Evaluate the parameter expression */
4869
4870 /*
4871 * Get string representation of each parameter value by invoking
4872 * type-specific output function, unless the value is null.
4873 */
4874 if (isNull)
4876 else
4878
4879 i++;
4880 }
4881
4883}
static Datum ExecEvalExpr(ExprState *state, ExprContext *econtext, bool *isNull)
Definition executor.h:393
Definition execnodes.h:87
References ExecEvalExpr(), fb(), i, lfirst, OutputFunctionCall(), reset_transmission_modes(), and set_transmission_modes().
Referenced by create_cursor(), and execute_dml_stmt().
◆ produce_tuple_asynchronously()
|
static |
Definition at line 7326 of file postgres_fdw.c.
7327{
7331 TupleTableSlot *result;
7332
7333 /* This should not be called if the request is currently in-process */
7335
7336 /* Fetch some more tuples, if we've run out */
7338 {
7339 /* No point in another fetch if we already detected EOF, though */
7341 {
7342 /* Mark the request as pending for a callback */
7344 /* Begin another fetch if requested and if no pending request */
7345 if (fetch && !pendingAreq)
7347 }
7348 else
7349 {
7350 /* There's nothing more to do; just return a NULL pointer */
7351 result = NULL;
7352 /* Mark the request as complete */
7354 }
7355 return;
7356 }
7357
7358 /* Get a tuple from the ForeignScan node */
7361 {
7362 /* Mark the request as complete */
7364 return;
7365 }
7366
7367 /* We must have run out of tuples */
7369
7370 /* Fetch some more tuples, if we've not detected EOF yet */
7372 {
7373 /* Mark the request as pending for a callback */
7375 /* Begin another fetch if requested and if no pending request */
7376 if (fetch && !pendingAreq)
7378 }
7379 else
7380 {
7381 /* There's nothing more to do; just return a NULL pointer */
7382 result = NULL;
7383 /* Mark the request as complete */
7385 }
7386}
References Assert, PgFdwScanState::conn_state, PgFdwScanState::eof_reached, ExecAsyncRequestDone(), ExecAsyncRequestPending(), fb(), ForeignScanState::fdw_state, fetch_more_data_begin(), PgFdwScanState::next_tuple, PgFdwScanState::num_tuples, PgFdwConnState::pendingAreq, and TupIsNull.
Referenced by complete_pending_request(), postgresForeignAsyncNotify(), and postgresForeignAsyncRequest().
◆ rebuild_fdw_scan_tlist()
|
static |
Definition at line 4489 of file postgres_fdw.c.
4490{
4494
4496 {
4498
4500 continue; /* already got it */
4501
4505 NULL,
4506 false));
4507 }
4509}
References fb(), lappend(), lfirst, list_length(), makeTargetEntry(), and tlist_member().
Referenced by postgresPlanDirectModify().
◆ reset_transmission_modes()
Definition at line 3929 of file postgres_fdw.c.
3930{
3932}
References AtEOXact_GUC(), and fb().
Referenced by appendConditions(), appendLimitClause(), appendOrderByClause(), convert_prep_stmt_params(), deparseDirectUpdateSql(), and process_query_params().
◆ semijoin_target_ok()
|
static |
Definition at line 5660 of file postgres_fdw.c.
5661{
5665
5667
5669
5671 {
5673
5675 continue;
5676
5678 {
5679 /*
5680 * The planner can create semi-join, which refers to inner rel
5681 * vars in its target list. However, we deparse semi-join as an
5682 * exists() subquery, so can't handle references to inner rel in
5683 * the target list.
5684 */
5687 break;
5688 }
5689 }
5691}
References Assert, bms_is_member(), PathTarget::exprs, fb(), IsA, lfirst, pull_var_clause(), PVC_INCLUDE_PLACEHOLDERS, RelOptInfo::relids, RelOptInfo::reltarget, and Var::varno.
Referenced by foreign_join_ok().
◆ set_transmission_modes()
Definition at line 3893 of file postgres_fdw.c.
3894{
3896
3897 /*
3898 * The values set here should match what pg_dump does. See also
3899 * configure_remote_session in connection.c.
3900 */
3913
3914 /*
3915 * In addition force restrictive search_path, in case there are any
3916 * regproc or similar constants to be printed.
3917 */
3921
3923}
int set_config_option(const char *name, const char *value, GucContext context, GucSource source, GucAction action, bool changeVal, int elevel, bool is_reload)
Definition guc.c:3216
References DateStyle, extra_float_digits, fb(), GUC_ACTION_SAVE, IntervalStyle, INTSTYLE_POSTGRES, NewGUCNestLevel(), PGC_S_SESSION, PGC_USERSET, set_config_option(), and USE_ISO_DATES.
Referenced by appendConditions(), appendLimitClause(), appendOrderByClause(), convert_prep_stmt_params(), deparseDirectUpdateSql(), and process_query_params().
◆ store_returning_result()
|
static |
Definition at line 4322 of file postgres_fdw.c.
4324{
4326
4328 fmstate->rel,
4329 fmstate->attinmeta,
4330 fmstate->retrieved_attrs,
4331 NULL,
4332 fmstate->temp_cxt);
4333
4334 /*
4335 * The returning slot will not necessarily be suitable to store heaptuples
4336 * directly, so allow for conversion.
4337 */
4339}
void ExecForceStoreHeapTuple(HeapTuple tuple, TupleTableSlot *slot, bool shouldFree)
Definition execTuples.c:1658
References ExecForceStoreHeapTuple(), fb(), and make_tuple_from_result_row().
Referenced by execute_foreign_modify().
