#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:

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

Typedefs
typedef struct PgFdwScanState	PgFdwScanState

typedef struct PgFdwModifyState	PgFdwModifyState

typedef struct PgFdwDirectModifyState	PgFdwDirectModifyState

typedef struct PgFdwAnalyzeState	PgFdwAnalyzeState

typedef struct ConversionLocation	ConversionLocation

Functions
	PG_MODULE_MAGIC_EXT (.name="postgres_fdw",.version=PG_VERSION)

	PG_FUNCTION_INFO_V1 (postgres_fdw_handler)

static void	postgresGetForeignRelSize (PlannerInfo root, RelOptInfo baserel, Oid foreigntableid)

static void	postgresGetForeignPaths (PlannerInfo root, RelOptInfo baserel, Oid foreigntableid)

static ForeignScan *	postgresGetForeignPlan (PlannerInfo root, RelOptInfo foreignrel, Oid foreigntableid, ForeignPath best_path, List tlist, List scan_clauses, Plan outer_plan)

static void	postgresBeginForeignScan (ForeignScanState *node, int eflags)

static TupleTableSlot *	postgresIterateForeignScan (ForeignScanState *node)

static void	postgresReScanForeignScan (ForeignScanState *node)

static void	postgresEndForeignScan (ForeignScanState *node)

static void	postgresAddForeignUpdateTargets (PlannerInfo root, Index rtindex, RangeTblEntry target_rte, Relation target_relation)

static List *	postgresPlanForeignModify (PlannerInfo root, ModifyTable plan, Index resultRelation, int subplan_index)

static void	postgresBeginForeignModify (ModifyTableState mtstate, ResultRelInfo resultRelInfo, List *fdw_private, int subplan_index, int eflags)

static TupleTableSlot *	postgresExecForeignInsert (EState estate, ResultRelInfo resultRelInfo, TupleTableSlot slot, TupleTableSlot planSlot)

static TupleTableSlot **	postgresExecForeignBatchInsert (EState estate, ResultRelInfo resultRelInfo, TupleTableSlot slots, TupleTableSlot planSlots, int *numSlots)

static int	postgresGetForeignModifyBatchSize (ResultRelInfo *resultRelInfo)

static TupleTableSlot *	postgresExecForeignUpdate (EState estate, ResultRelInfo resultRelInfo, TupleTableSlot slot, TupleTableSlot planSlot)

static TupleTableSlot *	postgresExecForeignDelete (EState estate, ResultRelInfo resultRelInfo, TupleTableSlot slot, TupleTableSlot planSlot)

static void	postgresEndForeignModify (EState estate, ResultRelInfo resultRelInfo)

static void	postgresBeginForeignInsert (ModifyTableState mtstate, ResultRelInfo resultRelInfo)

static void	postgresEndForeignInsert (EState estate, ResultRelInfo resultRelInfo)

static int	postgresIsForeignRelUpdatable (Relation rel)

static bool	postgresPlanDirectModify (PlannerInfo root, ModifyTable plan, Index resultRelation, int subplan_index)

static void	postgresBeginDirectModify (ForeignScanState *node, int eflags)

static TupleTableSlot *	postgresIterateDirectModify (ForeignScanState *node)

static void	postgresEndDirectModify (ForeignScanState *node)

static void	postgresExplainForeignScan (ForeignScanState node, ExplainState es)

static void	postgresExplainForeignModify (ModifyTableState mtstate, ResultRelInfo rinfo, List fdw_private, int subplan_index, ExplainState es)

static void	postgresExplainDirectModify (ForeignScanState node, ExplainState es)

static void	postgresExecForeignTruncate (List *rels, DropBehavior behavior, bool restart_seqs)

static bool	postgresAnalyzeForeignTable (Relation relation, AcquireSampleRowsFunc func, BlockNumber totalpages)

static List *	postgresImportForeignSchema (ImportForeignSchemaStmt *stmt, Oid serverOid)

static void	postgresGetForeignJoinPaths (PlannerInfo root, RelOptInfo joinrel, RelOptInfo outerrel, RelOptInfo innerrel, JoinType jointype, JoinPathExtraData *extra)

static bool	postgresRecheckForeignScan (ForeignScanState node, TupleTableSlot slot)

static void	postgresGetForeignUpperPaths (PlannerInfo root, UpperRelationKind stage, RelOptInfo input_rel, RelOptInfo output_rel, void extra)

static bool	postgresIsForeignPathAsyncCapable (ForeignPath *path)

static void	postgresForeignAsyncRequest (AsyncRequest *areq)

static void	postgresForeignAsyncConfigureWait (AsyncRequest *areq)

static void	postgresForeignAsyncNotify (AsyncRequest *areq)

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)

static void	get_remote_estimate (const char sql, PGconn conn, double rows, int width, Cost startup_cost, Cost total_cost)

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)

static bool	ec_member_matches_foreign (PlannerInfo root, RelOptInfo rel, EquivalenceClass ec, EquivalenceMember em, void *arg)

static void	create_cursor (ForeignScanState *node)

static void	fetch_more_data (ForeignScanState *node)

static void	close_cursor (PGconn conn, unsigned int cursor_number, PgFdwConnState conn_state)

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)

static TupleTableSlot **	execute_foreign_modify (EState estate, ResultRelInfo resultRelInfo, CmdType operation, TupleTableSlot slots, TupleTableSlot planSlots, int *numSlots)

static void	prepare_foreign_modify (PgFdwModifyState *fmstate)

static const char **	convert_prep_stmt_params (PgFdwModifyState fmstate, ItemPointer tupleid, TupleTableSlot *slots, int numSlots)

static void	store_returning_result (PgFdwModifyState fmstate, TupleTableSlot slot, PGresult *res)

static void	finish_foreign_modify (PgFdwModifyState *fmstate)

static void	deallocate_query (PgFdwModifyState *fmstate)

static List *	build_remote_returning (Index rtindex, Relation rel, List *returningList)

static void	rebuild_fdw_scan_tlist (ForeignScan fscan, List tlist)

static void	execute_dml_stmt (ForeignScanState *node)

static TupleTableSlot *	get_returning_data (ForeignScanState *node)

static void	init_returning_filter (PgFdwDirectModifyState dmstate, List fdw_scan_tlist, Index rtindex)

static TupleTableSlot *	apply_returning_filter (PgFdwDirectModifyState dmstate, ResultRelInfo resultRelInfo, TupleTableSlot slot, EState estate)

static void	prepare_query_params (PlanState node, List fdw_exprs, int numParams, FmgrInfo param_flinfo, List param_exprs, const char ***param_values)

static void	process_query_params (ExprContext econtext, FmgrInfo param_flinfo, List param_exprs, const char *param_values)

static int	postgresAcquireSampleRowsFunc (Relation relation, int elevel, HeapTuple rows, int targrows, double totalrows, double *totaldeadrows)

static void	analyze_row_processor (PGresult res, int row, PgFdwAnalyzeState astate)

static void	produce_tuple_asynchronously (AsyncRequest *areq, bool fetch)

static void	fetch_more_data_begin (AsyncRequest *areq)

static void	complete_pending_request (AsyncRequest *areq)

static HeapTuple	make_tuple_from_result_row (PGresult res, int row, Relation rel, AttInMetadata attinmeta, List retrieved_attrs, ForeignScanState fsstate, MemoryContext temp_context)

static void	conversion_error_callback (void *arg)

static bool	foreign_join_ok (PlannerInfo root, RelOptInfo joinrel, JoinType jointype, RelOptInfo outerrel, RelOptInfo innerrel, JoinPathExtraData *extra)

static bool	foreign_grouping_ok (PlannerInfo root, RelOptInfo grouped_rel, Node *havingQual)

static List *	get_useful_pathkeys_for_relation (PlannerInfo root, RelOptInfo rel)

static List *	get_useful_ecs_for_relation (PlannerInfo root, RelOptInfo rel)

static void	add_paths_with_pathkeys_for_rel (PlannerInfo root, RelOptInfo rel, Path epq_path, List restrictlist)

static void	add_foreign_grouping_paths (PlannerInfo root, RelOptInfo input_rel, RelOptInfo grouped_rel, GroupPathExtraData extra)

static void	add_foreign_ordered_paths (PlannerInfo root, RelOptInfo input_rel, RelOptInfo *ordered_rel)

static void	add_foreign_final_paths (PlannerInfo root, RelOptInfo input_rel, RelOptInfo final_rel, FinalPathExtraData extra)

static void	apply_server_options (PgFdwRelationInfo *fpinfo)

static void	apply_table_options (PgFdwRelationInfo *fpinfo)

static void	merge_fdw_options (PgFdwRelationInfo fpinfo, const PgFdwRelationInfo fpinfo_o, const PgFdwRelationInfo *fpinfo_i)

static int	get_batch_size_option (Relation rel)

Datum	postgres_fdw_handler (PG_FUNCTION_ARGS)

static TupleDesc	get_tupdesc_for_join_scan_tuples (ForeignScanState *node)

static ForeignScan *	find_modifytable_subplan (PlannerInfo root, ModifyTable plan, Index rtindex, int subplan_index)

int	set_transmission_modes (void)

void	reset_transmission_modes (int nestlevel)

static double	postgresGetAnalyzeInfoForForeignTable (Relation relation, bool *can_tablesample)

static bool	semijoin_target_ok (PlannerInfo root, RelOptInfo joinrel, RelOptInfo outerrel, RelOptInfo innerrel)

void	process_pending_request (AsyncRequest *areq)

EquivalenceMember *	find_em_for_rel (PlannerInfo root, EquivalenceClass ec, RelOptInfo *rel)

EquivalenceMember *	find_em_for_rel_target (PlannerInfo root, EquivalenceClass ec, RelOptInfo *rel)

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

typedef struct ConversionLocation ConversionLocation

◆ PgFdwAnalyzeState

typedef struct PgFdwAnalyzeState PgFdwAnalyzeState

◆ PgFdwDirectModifyState

typedef struct PgFdwDirectModifyState PgFdwDirectModifyState

◆ PgFdwModifyState

typedef struct PgFdwModifyState PgFdwModifyState

◆ PgFdwScanState

typedef struct PgFdwScanState PgFdwScanState

Enumeration Type Documentation

◆ FdwDirectModifyPrivateIndex

enum FdwDirectModifyPrivateIndex

Enumerator
FdwDirectModifyPrivateUpdateSql
FdwDirectModifyPrivateHasReturning
FdwDirectModifyPrivateRetrievedAttrs
FdwDirectModifyPrivateSetProcessed

Definition at line 124 of file postgres_fdw.c.

{
    /* SQL statement to execute remotely (as a String node) */
    FdwDirectModifyPrivateUpdateSql,
    /* has-returning flag (as a Boolean node) */
    FdwDirectModifyPrivateHasReturning,
    /* Integer list of attribute numbers retrieved by RETURNING */
    FdwDirectModifyPrivateRetrievedAttrs,
    /* set-processed flag (as a Boolean node) */
    FdwDirectModifyPrivateSetProcessed,
};

◆ FdwModifyPrivateIndex

enum FdwModifyPrivateIndex

Enumerator
FdwModifyPrivateUpdateSql
FdwModifyPrivateTargetAttnums
FdwModifyPrivateLen
FdwModifyPrivateHasReturning
FdwModifyPrivateRetrievedAttrs

Definition at line 101 of file postgres_fdw.c.

{
    /* SQL statement to execute remotely (as a String node) */
    FdwModifyPrivateUpdateSql,
    /* Integer list of target attribute numbers for INSERT/UPDATE */
    FdwModifyPrivateTargetAttnums,
    /* Length till the end of VALUES clause (as an Integer node) */
    FdwModifyPrivateLen,
    /* has-returning flag (as a Boolean node) */
    FdwModifyPrivateHasReturning,
    /* Integer list of attribute numbers retrieved by RETURNING */
    FdwModifyPrivateRetrievedAttrs,
};

◆ FdwPathPrivateIndex

enum FdwPathPrivateIndex

Enumerator
FdwPathPrivateHasFinalSort
FdwPathPrivateHasLimit

Definition at line 284 of file postgres_fdw.c.

{
    /* has-final-sort flag (as a Boolean node) */
    FdwPathPrivateHasFinalSort,
    /* has-limit flag (as a Boolean node) */
    FdwPathPrivateHasLimit,
};

◆ FdwScanPrivateIndex

enum FdwScanPrivateIndex

Enumerator
FdwScanPrivateSelectSql
FdwScanPrivateRetrievedAttrs
FdwScanPrivateFetchSize
FdwScanPrivateRelations

Definition at line 73 of file postgres_fdw.c.

{
    /* SQL statement to execute remotely (as a String node) */
    FdwScanPrivateSelectSql,
    /* Integer list of attribute numbers retrieved by the SELECT */
    FdwScanPrivateRetrievedAttrs,
    /* Integer representing the desired fetch_size */
    FdwScanPrivateFetchSize,
 
    /*
     * String describing join i.e. names of relations being joined and types
     * of join, added when the scan is join
     */
    FdwScanPrivateRelations,
};

Function Documentation

◆ add_foreign_final_paths()

static void add_foreign_final_paths	(	PlannerInfo *	root,
		RelOptInfo *	input_rel,
		RelOptInfo *	final_rel,
		FinalPathExtraData *	extra
	)

static

Definition at line 6935 of file postgres_fdw.c.

{
    Query      *parse = root->parse;
    PgFdwRelationInfo *ifpinfo = (PgFdwRelationInfo *) input_rel->fdw_private;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) final_rel->fdw_private;
    bool        has_final_sort = false;
    List       *pathkeys = NIL;
    PgFdwPathExtraData *fpextra;
    bool        save_use_remote_estimate = false;
    double      rows;
    int         width;
    int         disabled_nodes;
    Cost        startup_cost;
    Cost        total_cost;
    List       *fdw_private;
    ForeignPath *final_path;
 
    /*
     * Currently, we only support this for SELECT commands
     */
    if (parse->commandType != CMD_SELECT)
        return;
 
    /*
     * No work if there is no FOR UPDATE/SHARE clause and if there is no need
     * to add a LIMIT node
     */
    if (!parse->rowMarks && !extra->limit_needed)
        return;
 
    /* We don't support cases where there are any SRFs in the targetlist */
    if (parse->hasTargetSRFs)
        return;
 
    /* Save the input_rel as outerrel in fpinfo */
    fpinfo->outerrel = input_rel;
 
    /*
     * Copy foreign table, foreign server, user mapping, FDW options etc.
     * details from the input relation's fpinfo.
     */
    fpinfo->table = ifpinfo->table;
    fpinfo->server = ifpinfo->server;
    fpinfo->user = ifpinfo->user;
    merge_fdw_options(fpinfo, ifpinfo, NULL);
 
    /*
     * If there is no need to add a LIMIT node, there might be a ForeignPath
     * in the input_rel's pathlist that implements all behavior of the query.
     * Note: we would already have accounted for the query's FOR UPDATE/SHARE
     * (if any) before we get here.
     */
    if (!extra->limit_needed)
    {
        ListCell   *lc;
 
        Assert(parse->rowMarks);
 
        /*
         * Grouping and aggregation are not supported with FOR UPDATE/SHARE,
         * so the input_rel should be a base, join, or ordered relation; and
         * if it's an ordered relation, its input relation should be a base or
         * join relation.
         */
        Assert(input_rel->reloptkind == RELOPT_BASEREL ||
               input_rel->reloptkind == RELOPT_JOINREL ||
               (input_rel->reloptkind == RELOPT_UPPER_REL &&
                ifpinfo->stage == UPPERREL_ORDERED &&
                (ifpinfo->outerrel->reloptkind == RELOPT_BASEREL ||
                 ifpinfo->outerrel->reloptkind == RELOPT_JOINREL)));
 
        foreach(lc, input_rel->pathlist)
        {
            Path       *path = (Path *) lfirst(lc);
 
            /*
             * apply_scanjoin_target_to_paths() uses create_projection_path()
             * to adjust each of its input paths if needed, whereas
             * create_ordered_paths() uses apply_projection_to_path() to do
             * that.  So the former might have put a ProjectionPath on top of
             * the ForeignPath; look through ProjectionPath and see if the
             * path underneath it is ForeignPath.
             */
            if (IsA(path, ForeignPath) ||
                (IsA(path, ProjectionPath) &&
                 IsA(((ProjectionPath *) path)->subpath, ForeignPath)))
            {
                /*
                 * Create foreign final path; this gets rid of a
                 * no-longer-needed outer plan (if any), which makes the
                 * EXPLAIN output look cleaner
                 */
                final_path = create_foreign_upper_path(root,
                                                       path->parent,
                                                       path->pathtarget,
                                                       path->rows,
                                                       path->disabled_nodes,
                                                       path->startup_cost,
                                                       path->total_cost,
                                                       path->pathkeys,
                                                       NULL,    /* no extra plan */
                                                       NIL, /* no fdw_restrictinfo
                                                             * list */
                                                       NIL);    /* no fdw_private */
 
                /* and add it to the final_rel */
                add_path(final_rel, (Path *) final_path);
 
                /* Safe to push down */
                fpinfo->pushdown_safe = true;
 
                return;
            }
        }
 
        /*
         * If we get here it means no ForeignPaths; since we would already
         * have considered pushing down all operations for the query to the
         * remote server, give up on it.
         */
        return;
    }
 
    Assert(extra->limit_needed);
 
    /*
     * If the input_rel is an ordered relation, replace the input_rel with its
     * input relation
     */
    if (input_rel->reloptkind == RELOPT_UPPER_REL &&
        ifpinfo->stage == UPPERREL_ORDERED)
    {
        input_rel = ifpinfo->outerrel;
        ifpinfo = (PgFdwRelationInfo *) input_rel->fdw_private;
        has_final_sort = true;
        pathkeys = root->sort_pathkeys;
    }
 
    /* The input_rel should be a base, join, or grouping relation */
    Assert(input_rel->reloptkind == RELOPT_BASEREL ||
           input_rel->reloptkind == RELOPT_JOINREL ||
           (input_rel->reloptkind == RELOPT_UPPER_REL &&
            ifpinfo->stage == UPPERREL_GROUP_AGG));
 
    /*
     * We try to create a path below by extending a simple foreign path for
     * the underlying base, join, or grouping relation to perform the final
     * sort (if has_final_sort) and the LIMIT restriction remotely, which is
     * stored into the fdw_private list of the resulting path.  (We
     * re-estimate the costs of sorting the underlying relation, if
     * has_final_sort.)
     */
 
    /*
     * Assess if it is safe to push down the LIMIT and OFFSET to the remote
     * server
     */
 
    /*
     * If the underlying relation has any local conditions, the LIMIT/OFFSET
     * cannot be pushed down.
     */
    if (ifpinfo->local_conds)
        return;
 
    /*
     * If the query has FETCH FIRST .. WITH TIES, 1) it must have ORDER BY as
     * well, which is used to determine which additional rows tie for the last
     * place in the result set, and 2) ORDER BY must already have been
     * determined to be safe to push down before we get here.  So in that case
     * the FETCH clause is safe to push down with ORDER BY if the remote
     * server is v13 or later, but if not, the remote query will fail entirely
     * for lack of support for it.  Since we do not currently have a way to do
     * a remote-version check (without accessing the remote server), disable
     * pushing the FETCH clause for now.
     */
    if (parse->limitOption == LIMIT_OPTION_WITH_TIES)
        return;
 
    /*
     * Also, the LIMIT/OFFSET cannot be pushed down, if their expressions are
     * not safe to remote.
     */
    if (!is_foreign_expr(root, input_rel, (Expr *) parse->limitOffset) ||
        !is_foreign_expr(root, input_rel, (Expr *) parse->limitCount))
        return;
 
    /* Safe to push down */
    fpinfo->pushdown_safe = true;
 
    /* Construct PgFdwPathExtraData */
    fpextra = (PgFdwPathExtraData *) palloc0(sizeof(PgFdwPathExtraData));
    fpextra->target = root->upper_targets[UPPERREL_FINAL];
    fpextra->has_final_sort = has_final_sort;
    fpextra->has_limit = extra->limit_needed;
    fpextra->limit_tuples = extra->limit_tuples;
    fpextra->count_est = extra->count_est;
    fpextra->offset_est = extra->offset_est;
 
    /*
     * Estimate the costs of performing the final sort and the LIMIT
     * restriction remotely.  If has_final_sort is false, we wouldn't need to
     * execute EXPLAIN anymore if use_remote_estimate, since the costs can be
     * roughly estimated using the costs we already have for the underlying
     * relation, in the same way as when use_remote_estimate is false.  Since
     * it's pretty expensive to execute EXPLAIN, force use_remote_estimate to
     * false in that case.
     */
    if (!fpextra->has_final_sort)
    {
        save_use_remote_estimate = ifpinfo->use_remote_estimate;
        ifpinfo->use_remote_estimate = false;
    }
    estimate_path_cost_size(root, input_rel, NIL, pathkeys, fpextra,
                            &rows, &width, &disabled_nodes,
                            &startup_cost, &total_cost);
    if (!fpextra->has_final_sort)
        ifpinfo->use_remote_estimate = save_use_remote_estimate;
 
    /*
     * Build the fdw_private list that will be used by postgresGetForeignPlan.
     * Items in the list must match order in enum FdwPathPrivateIndex.
     */
    fdw_private = list_make2(makeBoolean(has_final_sort),
                             makeBoolean(extra->limit_needed));
 
    /*
     * Create foreign final path; this gets rid of a no-longer-needed outer
     * plan (if any), which makes the EXPLAIN output look cleaner
     */
    final_path = create_foreign_upper_path(root,
                                           input_rel,
                                           root->upper_targets[UPPERREL_FINAL],
                                           rows,
                                           disabled_nodes,
                                           startup_cost,
                                           total_cost,
                                           pathkeys,
                                           NULL,    /* no extra plan */
                                           NIL, /* no fdw_restrictinfo list */
                                           fdw_private);
 
    /* and add it to the final_rel */
    add_path(final_rel, (Path *) final_path);
}

References add_path(), Assert(), CMD_SELECT, PgFdwPathExtraData::count_est, FinalPathExtraData::count_est, create_foreign_upper_path(), Path::disabled_nodes, estimate_path_cost_size(), PgFdwPathExtraData::has_final_sort, PgFdwPathExtraData::has_limit, is_foreign_expr(), IsA, lfirst, FinalPathExtraData::limit_needed, LIMIT_OPTION_WITH_TIES, PgFdwPathExtraData::limit_tuples, FinalPathExtraData::limit_tuples, list_make2, PgFdwRelationInfo::local_conds, makeBoolean(), merge_fdw_options(), NIL, PgFdwPathExtraData::offset_est, FinalPathExtraData::offset_est, PgFdwRelationInfo::outerrel, palloc0(), parse(), Path::pathkeys, RelOptInfo::pathlist, RELOPT_BASEREL, RELOPT_JOINREL, RELOPT_UPPER_REL, RelOptInfo::reloptkind, root, Path::rows, PgFdwRelationInfo::server, PgFdwRelationInfo::stage, Path::startup_cost, subpath(), PgFdwRelationInfo::table, PgFdwPathExtraData::target, Path::total_cost, UPPERREL_FINAL, UPPERREL_GROUP_AGG, UPPERREL_ORDERED, PgFdwRelationInfo::use_remote_estimate, and PgFdwRelationInfo::user.

Referenced by postgresGetForeignUpperPaths().

◆ add_foreign_grouping_paths()

static void add_foreign_grouping_paths	(	PlannerInfo *	root,
		RelOptInfo *	input_rel,
		RelOptInfo *	grouped_rel,
		GroupPathExtraData *	extra
	)

static

Definition at line 6701 of file postgres_fdw.c.

{
    Query      *parse = root->parse;
    PgFdwRelationInfo *ifpinfo = input_rel->fdw_private;
    PgFdwRelationInfo *fpinfo = grouped_rel->fdw_private;
    ForeignPath *grouppath;
    double      rows;
    int         width;
    int         disabled_nodes;
    Cost        startup_cost;
    Cost        total_cost;
 
    /* Nothing to be done, if there is no grouping or aggregation required. */
    if (!parse->groupClause && !parse->groupingSets && !parse->hasAggs &&
        !root->hasHavingQual)
        return;
 
    Assert(extra->patype == PARTITIONWISE_AGGREGATE_NONE ||
           extra->patype == PARTITIONWISE_AGGREGATE_FULL);
 
    /* save the input_rel as outerrel in fpinfo */
    fpinfo->outerrel = input_rel;
 
    /*
     * Copy foreign table, foreign server, user mapping, FDW options etc.
     * details from the input relation's fpinfo.
     */
    fpinfo->table = ifpinfo->table;
    fpinfo->server = ifpinfo->server;
    fpinfo->user = ifpinfo->user;
    merge_fdw_options(fpinfo, ifpinfo, NULL);
 
    /*
     * Assess if it is safe to push down aggregation and grouping.
     *
     * Use HAVING qual from extra. In case of child partition, it will have
     * translated Vars.
     */
    if (!foreign_grouping_ok(root, grouped_rel, extra->havingQual))
        return;
 
    /*
     * Compute the selectivity and cost of the local_conds, so we don't have
     * to do it over again for each path.  (Currently we create just a single
     * path here, but in future it would be possible that we build more paths
     * such as pre-sorted paths as in postgresGetForeignPaths and
     * postgresGetForeignJoinPaths.)  The best we can do for these conditions
     * is to estimate selectivity on the basis of local statistics.
     */
    fpinfo->local_conds_sel = clauselist_selectivity(root,
                                                     fpinfo->local_conds,
                                                     0,
                                                     JOIN_INNER,
                                                     NULL);
 
    cost_qual_eval(&fpinfo->local_conds_cost, fpinfo->local_conds, root);
 
    /* Estimate the cost of push down */
    estimate_path_cost_size(root, grouped_rel, NIL, NIL, NULL,
                            &rows, &width, &disabled_nodes,
                            &startup_cost, &total_cost);
 
    /* Now update this information in the fpinfo */
    fpinfo->rows = rows;
    fpinfo->width = width;
    fpinfo->disabled_nodes = disabled_nodes;
    fpinfo->startup_cost = startup_cost;
    fpinfo->total_cost = total_cost;
 
    /* Create and add foreign path to the grouping relation. */
    grouppath = create_foreign_upper_path(root,
                                          grouped_rel,
                                          grouped_rel->reltarget,
                                          rows,
                                          disabled_nodes,
                                          startup_cost,
                                          total_cost,
                                          NIL,  /* no pathkeys */
                                          NULL,
                                          NIL,  /* no fdw_restrictinfo list */
                                          NIL); /* no fdw_private */
 
    /* Add generated path into grouped_rel by add_path(). */
    add_path(grouped_rel, (Path *) grouppath);
}

Referenced by postgresGetForeignUpperPaths().

◆ add_foreign_ordered_paths()

static void add_foreign_ordered_paths	(	PlannerInfo *	root,
		RelOptInfo *	input_rel,
		RelOptInfo *	ordered_rel
	)

static

Definition at line 6797 of file postgres_fdw.c.

{
    Query      *parse = root->parse;
    PgFdwRelationInfo *ifpinfo = input_rel->fdw_private;
    PgFdwRelationInfo *fpinfo = ordered_rel->fdw_private;
    PgFdwPathExtraData *fpextra;
    double      rows;
    int         width;
    int         disabled_nodes;
    Cost        startup_cost;
    Cost        total_cost;
    List       *fdw_private;
    ForeignPath *ordered_path;
    ListCell   *lc;
 
    /* Shouldn't get here unless the query has ORDER BY */
    Assert(parse->sortClause);
 
    /* We don't support cases where there are any SRFs in the targetlist */
    if (parse->hasTargetSRFs)
        return;
 
    /* Save the input_rel as outerrel in fpinfo */
    fpinfo->outerrel = input_rel;
 
    /*
     * Copy foreign table, foreign server, user mapping, FDW options etc.
     * details from the input relation's fpinfo.
     */
    fpinfo->table = ifpinfo->table;
    fpinfo->server = ifpinfo->server;
    fpinfo->user = ifpinfo->user;
    merge_fdw_options(fpinfo, ifpinfo, NULL);
 
    /*
     * If the input_rel is a base or join relation, we would already have
     * considered pushing down the final sort to the remote server when
     * creating pre-sorted foreign paths for that relation, because the
     * query_pathkeys is set to the root->sort_pathkeys in that case (see
     * standard_qp_callback()).
     */
    if (input_rel->reloptkind == RELOPT_BASEREL ||
        input_rel->reloptkind == RELOPT_JOINREL)
    {
        Assert(root->query_pathkeys == root->sort_pathkeys);
 
        /* Safe to push down if the query_pathkeys is safe to push down */
        fpinfo->pushdown_safe = ifpinfo->qp_is_pushdown_safe;
 
        return;
    }
 
    /* The input_rel should be a grouping relation */
    Assert(input_rel->reloptkind == RELOPT_UPPER_REL &&
           ifpinfo->stage == UPPERREL_GROUP_AGG);
 
    /*
     * We try to create a path below by extending a simple foreign path for
     * the underlying grouping relation to perform the final sort remotely,
     * which is stored into the fdw_private list of the resulting path.
     */
 
    /* Assess if it is safe to push down the final sort */
    foreach(lc, root->sort_pathkeys)
    {
        PathKey    *pathkey = (PathKey *) lfirst(lc);
        EquivalenceClass *pathkey_ec = pathkey->pk_eclass;
 
        /*
         * is_foreign_expr would detect volatile expressions as well, but
         * checking ec_has_volatile here saves some cycles.
         */
        if (pathkey_ec->ec_has_volatile)
            return;
 
        /*
         * Can't push down the sort if pathkey's opfamily is not shippable.
         */
        if (!is_shippable(pathkey->pk_opfamily, OperatorFamilyRelationId,
                          fpinfo))
            return;
 
        /*
         * The EC must contain a shippable EM that is computed in input_rel's
         * reltarget, else we can't push down the sort.
         */
        if (find_em_for_rel_target(root,
                                   pathkey_ec,
                                   input_rel) == NULL)
            return;
    }
 
    /* Safe to push down */
    fpinfo->pushdown_safe = true;
 
    /* Construct PgFdwPathExtraData */
    fpextra = (PgFdwPathExtraData *) palloc0(sizeof(PgFdwPathExtraData));
    fpextra->target = root->upper_targets[UPPERREL_ORDERED];
    fpextra->has_final_sort = true;
 
    /* Estimate the costs of performing the final sort remotely */
    estimate_path_cost_size(root, input_rel, NIL, root->sort_pathkeys, fpextra,
                            &rows, &width, &disabled_nodes,
                            &startup_cost, &total_cost);
 
    /*
     * Build the fdw_private list that will be used by postgresGetForeignPlan.
     * Items in the list must match order in enum FdwPathPrivateIndex.
     */
    fdw_private = list_make2(makeBoolean(true), makeBoolean(false));
 
    /* Create foreign ordering path */
    ordered_path = create_foreign_upper_path(root,
                                             input_rel,
                                             root->upper_targets[UPPERREL_ORDERED],
                                             rows,
                                             disabled_nodes,
                                             startup_cost,
                                             total_cost,
                                             root->sort_pathkeys,
                                             NULL,  /* no extra plan */
                                             NIL,   /* no fdw_restrictinfo
                                                     * list */
                                             fdw_private);
 
    /* and add it to the ordered_rel */
    add_path(ordered_rel, (Path *) ordered_path);
}

References add_path(), Assert(), create_foreign_upper_path(), EquivalenceClass::ec_has_volatile, estimate_path_cost_size(), find_em_for_rel_target(), PgFdwPathExtraData::has_final_sort, is_shippable(), lfirst, list_make2, makeBoolean(), merge_fdw_options(), NIL, PgFdwRelationInfo::outerrel, palloc0(), parse(), PathKey::pk_opfamily, PgFdwRelationInfo::pushdown_safe, PgFdwRelationInfo::qp_is_pushdown_safe, RELOPT_BASEREL, RELOPT_JOINREL, RELOPT_UPPER_REL, RelOptInfo::reloptkind, root, PgFdwRelationInfo::server, PgFdwRelationInfo::stage, PgFdwRelationInfo::table, PgFdwPathExtraData::target, UPPERREL_GROUP_AGG, UPPERREL_ORDERED, and PgFdwRelationInfo::user.

Referenced by postgresGetForeignUpperPaths().

◆ add_paths_with_pathkeys_for_rel()

static void add_paths_with_pathkeys_for_rel	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		Path *	epq_path,
		List *	restrictlist
	)

static

Definition at line 6020 of file postgres_fdw.c.

{
    List       *useful_pathkeys_list = NIL; /* List of all pathkeys */
    ListCell   *lc;
 
    useful_pathkeys_list = get_useful_pathkeys_for_relation(root, rel);
 
    /*
     * Before creating sorted paths, arrange for the passed-in EPQ path, if
     * any, to return columns needed by the parent ForeignScan node so that
     * they will propagate up through Sort nodes injected below, if necessary.
     */
    if (epq_path != NULL && useful_pathkeys_list != NIL)
    {
        PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) rel->fdw_private;
        PathTarget *target = copy_pathtarget(epq_path->pathtarget);
 
        /* Include columns required for evaluating PHVs in the tlist. */
        add_new_columns_to_pathtarget(target,
                                      pull_var_clause((Node *) target->exprs,
                                                      PVC_RECURSE_PLACEHOLDERS));
 
        /* Include columns required for evaluating the local conditions. */
        foreach(lc, fpinfo->local_conds)
        {
            RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
 
            add_new_columns_to_pathtarget(target,
                                          pull_var_clause((Node *) rinfo->clause,
                                                          PVC_RECURSE_PLACEHOLDERS));
        }
 
        /*
         * If we have added any new columns, adjust the tlist of the EPQ path.
         *
         * Note: the plan created using this path will only be used to execute
         * EPQ checks, where accuracy of the plan cost and width estimates
         * would not be important, so we do not do set_pathtarget_cost_width()
         * for the new pathtarget here.  See also postgresGetForeignPlan().
         */
        if (list_length(target->exprs) > list_length(epq_path->pathtarget->exprs))
        {
            /* The EPQ path is a join path, so it is projection-capable. */
            Assert(is_projection_capable_path(epq_path));
 
            /*
             * Use create_projection_path() here, so as to avoid modifying it
             * in place.
             */
            epq_path = (Path *) create_projection_path(root,
                                                       rel,
                                                       epq_path,
                                                       target);
        }
    }
 
    /* Create one path for each set of pathkeys we found above. */
    foreach(lc, useful_pathkeys_list)
    {
        double      rows;
        int         width;
        int         disabled_nodes;
        Cost        startup_cost;
        Cost        total_cost;
        List       *useful_pathkeys = lfirst(lc);
        Path       *sorted_epq_path;
 
        estimate_path_cost_size(root, rel, NIL, useful_pathkeys, NULL,
                                &rows, &width, &disabled_nodes,
                                &startup_cost, &total_cost);
 
        /*
         * The EPQ path must be at least as well sorted as the path itself, in
         * case it gets used as input to a mergejoin.
         */
        sorted_epq_path = epq_path;
        if (sorted_epq_path != NULL &&
            !pathkeys_contained_in(useful_pathkeys,
                                   sorted_epq_path->pathkeys))
            sorted_epq_path = (Path *)
                create_sort_path(root,
                                 rel,
                                 sorted_epq_path,
                                 useful_pathkeys,
                                 -1.0);
 
        if (IS_SIMPLE_REL(rel))
            add_path(rel, (Path *)
                     create_foreignscan_path(root, rel,
                                             NULL,
                                             rows,
                                             disabled_nodes,
                                             startup_cost,
                                             total_cost,
                                             useful_pathkeys,
                                             rel->lateral_relids,
                                             sorted_epq_path,
                                             NIL,   /* no fdw_restrictinfo
                                                     * list */
                                             NIL));
        else
            add_path(rel, (Path *)
                     create_foreign_join_path(root, rel,
                                              NULL,
                                              rows,
                                              disabled_nodes,
                                              startup_cost,
                                              total_cost,
                                              useful_pathkeys,
                                              rel->lateral_relids,
                                              sorted_epq_path,
                                              restrictlist,
                                              NIL));
    }
}

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(), get_useful_pathkeys_for_relation(), is_projection_capable_path(), IS_SIMPLE_REL, RelOptInfo::lateral_relids, lfirst, lfirst_node, list_length(), PgFdwRelationInfo::local_conds, NIL, Path::pathkeys, pathkeys_contained_in(), pull_var_clause(), PVC_RECURSE_PLACEHOLDERS, and root.

Referenced by postgresGetForeignJoinPaths(), and postgresGetForeignPaths().

◆ adjust_foreign_grouping_path_cost()

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
	)

static

Definition at line 3640 of file postgres_fdw.c.

{
    /*
     * If the GROUP BY clause isn't sort-able, the plan chosen by the remote
     * side is unlikely to generate properly-sorted output, so it would need
     * an explicit sort; adjust the given costs with cost_sort().  Likewise,
     * if the GROUP BY clause is sort-able but isn't a superset of the given
     * pathkeys, adjust the costs with that function.  Otherwise, adjust the
     * costs by applying the same heuristic as for the scan or join case.
     */
    if (!grouping_is_sortable(root->processed_groupClause) ||
        !pathkeys_contained_in(pathkeys, root->group_pathkeys))
    {
        Path        sort_path;  /* dummy for result of cost_sort */
 
        cost_sort(&sort_path,
                  root,
                  pathkeys,
                  0,
                  *p_startup_cost + *p_run_cost,
                  retrieved_rows,
                  width,
                  0.0,
                  work_mem,
                  limit_tuples);
 
        *p_startup_cost = sort_path.startup_cost;
        *p_run_cost = sort_path.total_cost - sort_path.startup_cost;
    }
    else
    {
        /*
         * The default extra cost seems too large for foreign-grouping cases;
         * add 1/4th of that default.
         */
        double      sort_multiplier = 1.0 + (DEFAULT_FDW_SORT_MULTIPLIER
                                             - 1.0) * 0.25;
 
        *p_startup_cost *= sort_multiplier;
        *p_run_cost *= sort_multiplier;
    }
}

References cost_sort(), DEFAULT_FDW_SORT_MULTIPLIER, grouping_is_sortable(), pathkeys_contained_in(), root, Path::startup_cost, Path::total_cost, and work_mem.

Referenced by estimate_path_cost_size().

◆ analyze_row_processor()

static void analyze_row_processor	(	PGresult *	res,
		int	row,
		PgFdwAnalyzeState *	astate
	)

static

Definition at line 5306 of file postgres_fdw.c.

{
    int         targrows = astate->targrows;
    int         pos;            /* array index to store tuple in */
    MemoryContext oldcontext;
 
    /* Always increment sample row counter. */
    astate->samplerows += 1;
 
    /*
     * Determine the slot where this sample row should be stored.  Set pos to
     * negative value to indicate the row should be skipped.
     */
    if (astate->numrows < targrows)
    {
        /* First targrows rows are always included into the sample */
        pos = astate->numrows++;
    }
    else
    {
        /*
         * Now we start replacing tuples in the sample until we reach the end
         * of the relation.  Same algorithm as in acquire_sample_rows in
         * analyze.c; see Jeff Vitter's paper.
         */
        if (astate->rowstoskip < 0)
            astate->rowstoskip = reservoir_get_next_S(&astate->rstate, astate->samplerows, targrows);
 
        if (astate->rowstoskip <= 0)
        {
            /* Choose a random reservoir element to replace. */
            pos = (int) (targrows * sampler_random_fract(&astate->rstate.randstate));
            Assert(pos >= 0 && pos < targrows);
            heap_freetuple(astate->rows[pos]);
        }
        else
        {
            /* Skip this tuple. */
            pos = -1;
        }
 
        astate->rowstoskip -= 1;
    }
 
    if (pos >= 0)
    {
        /*
         * Create sample tuple from current result row, and store it in the
         * position determined above.  The tuple has to be created in anl_cxt.
         */
        oldcontext = MemoryContextSwitchTo(astate->anl_cxt);
 
        astate->rows[pos] = make_tuple_from_result_row(res, row,
                                                       astate->rel,
                                                       astate->attinmeta,
                                                       astate->retrieved_attrs,
                                                       NULL,
                                                       astate->temp_cxt);
 
        MemoryContextSwitchTo(oldcontext);
    }
}

References PgFdwAnalyzeState::anl_cxt, Assert(), PgFdwAnalyzeState::attinmeta, 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 TupleTableSlot * apply_returning_filter	(	PgFdwDirectModifyState *	dmstate,
		ResultRelInfo *	resultRelInfo,
		TupleTableSlot *	slot,
		EState *	estate
	)

static

Definition at line 4705 of file postgres_fdw.c.

{
    TupleDesc   resultTupType = RelationGetDescr(dmstate->resultRel);
    TupleTableSlot *resultSlot;
    Datum      *values;
    bool       *isnull;
    Datum      *old_values;
    bool       *old_isnull;
    int         i;
 
    /*
     * Use the return tuple slot as a place to store the result tuple.
     */
    resultSlot = ExecGetReturningSlot(estate, resultRelInfo);
 
    /*
     * Extract all the values of the scan tuple.
     */
    slot_getallattrs(slot);
    old_values = slot->tts_values;
    old_isnull = slot->tts_isnull;
 
    /*
     * Prepare to build the result tuple.
     */
    ExecClearTuple(resultSlot);
    values = resultSlot->tts_values;
    isnull = resultSlot->tts_isnull;
 
    /*
     * Transpose data into proper fields of the result tuple.
     */
    for (i = 0; i < resultTupType->natts; i++)
    {
        int         j = dmstate->attnoMap[i];
 
        if (j == 0)
        {
            values[i] = (Datum) 0;
            isnull[i] = true;
        }
        else
        {
            values[i] = old_values[j - 1];
            isnull[i] = old_isnull[j - 1];
        }
    }
 
    /*
     * Build the virtual tuple.
     */
    ExecStoreVirtualTuple(resultSlot);
 
    /*
     * If we have any system columns to return, materialize a heap tuple in
     * the slot from column values set above and install system columns in
     * that tuple.
     */
    if (dmstate->hasSystemCols)
    {
        HeapTuple   resultTup = ExecFetchSlotHeapTuple(resultSlot, true, NULL);
 
        /* ctid */
        if (dmstate->ctidAttno)
        {
            ItemPointer ctid = NULL;
 
            ctid = (ItemPointer) DatumGetPointer(old_values[dmstate->ctidAttno - 1]);
            resultTup->t_self = *ctid;
        }
 
        /*
         * And remaining columns
         *
         * Note: since we currently don't allow the target relation to appear
         * on the nullable side of an outer join, any system columns wouldn't
         * go to NULL.
         *
         * Note: no need to care about tableoid here because it will be
         * initialized in ExecProcessReturning().
         */
        HeapTupleHeaderSetXmin(resultTup->t_data, InvalidTransactionId);
        HeapTupleHeaderSetXmax(resultTup->t_data, InvalidTransactionId);
        HeapTupleHeaderSetCmin(resultTup->t_data, InvalidTransactionId);
    }
 
    /*
     * And return the result tuple.
     */
    return resultSlot;
}

References PgFdwDirectModifyState::attnoMap, PgFdwDirectModifyState::ctidAttno, DatumGetPointer(), ExecClearTuple(), ExecFetchSlotHeapTuple(), ExecGetReturningSlot(), ExecStoreVirtualTuple(), PgFdwDirectModifyState::hasSystemCols, HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), i, InvalidTransactionId, j, TupleDescData::natts, RelationGetDescr, PgFdwDirectModifyState::resultRel, slot_getallattrs(), HeapTupleData::t_data, HeapTupleData::t_self, TupleTableSlot::tts_isnull, TupleTableSlot::tts_values, and values.

Referenced by get_returning_data().

◆ apply_server_options()

static void apply_server_options ( PgFdwRelationInfo * fpinfo )

static

Definition at line 6143 of file postgres_fdw.c.

{
    ListCell   *lc;
 
    foreach(lc, fpinfo->server->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "use_remote_estimate") == 0)
            fpinfo->use_remote_estimate = defGetBoolean(def);
        else if (strcmp(def->defname, "fdw_startup_cost") == 0)
            (void) parse_real(defGetString(def), &fpinfo->fdw_startup_cost, 0,
                              NULL);
        else if (strcmp(def->defname, "fdw_tuple_cost") == 0)
            (void) parse_real(defGetString(def), &fpinfo->fdw_tuple_cost, 0,
                              NULL);
        else if (strcmp(def->defname, "extensions") == 0)
            fpinfo->shippable_extensions =
                ExtractExtensionList(defGetString(def), false);
        else if (strcmp(def->defname, "fetch_size") == 0)
            (void) parse_int(defGetString(def), &fpinfo->fetch_size, 0, NULL);
        else if (strcmp(def->defname, "async_capable") == 0)
            fpinfo->async_capable = defGetBoolean(def);
    }
}

References PgFdwRelationInfo::async_capable, defGetBoolean(), defGetString(), DefElem::defname, ExtractExtensionList(), PgFdwRelationInfo::fdw_startup_cost, PgFdwRelationInfo::fdw_tuple_cost, PgFdwRelationInfo::fetch_size, lfirst, ForeignServer::options, parse_int(), parse_real(), PgFdwRelationInfo::server, PgFdwRelationInfo::shippable_extensions, and PgFdwRelationInfo::use_remote_estimate.

Referenced by postgresGetForeignRelSize().

◆ apply_table_options()

static void apply_table_options ( PgFdwRelationInfo * fpinfo )

static

Definition at line 6175 of file postgres_fdw.c.

{
    ListCell   *lc;
 
    foreach(lc, fpinfo->table->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "use_remote_estimate") == 0)
            fpinfo->use_remote_estimate = defGetBoolean(def);
        else if (strcmp(def->defname, "fetch_size") == 0)
            (void) parse_int(defGetString(def), &fpinfo->fetch_size, 0, NULL);
        else if (strcmp(def->defname, "async_capable") == 0)
            fpinfo->async_capable = defGetBoolean(def);
    }
}

References PgFdwRelationInfo::async_capable, defGetBoolean(), defGetString(), DefElem::defname, PgFdwRelationInfo::fetch_size, lfirst, ForeignTable::options, parse_int(), PgFdwRelationInfo::table, and PgFdwRelationInfo::use_remote_estimate.

Referenced by postgresGetForeignRelSize().

◆ build_remote_returning()

static List * build_remote_returning	(	Index	rtindex,
		Relation	rel,
		List *	returningList
	)

static

Definition at line 4388 of file postgres_fdw.c.

{
    bool        have_wholerow = false;
    List       *tlist = NIL;
    List       *vars;
    ListCell   *lc;
 
    Assert(returningList);
 
    vars = pull_var_clause((Node *) returningList, PVC_INCLUDE_PLACEHOLDERS);
 
    /*
     * If there's a whole-row reference to the target relation, then we'll
     * need all the columns of the relation.
     */
    foreach(lc, vars)
    {
        Var        *var = (Var *) lfirst(lc);
 
        if (IsA(var, Var) &&
            var->varno == rtindex &&
            var->varattno == InvalidAttrNumber)
        {
            have_wholerow = true;
            break;
        }
    }
 
    if (have_wholerow)
    {
        TupleDesc   tupdesc = RelationGetDescr(rel);
        int         i;
 
        for (i = 1; i <= tupdesc->natts; i++)
        {
            Form_pg_attribute attr = TupleDescAttr(tupdesc, i - 1);
            Var        *var;
 
            /* Ignore dropped attributes. */
            if (attr->attisdropped)
                continue;
 
            var = makeVar(rtindex,
                          i,
                          attr->atttypid,
                          attr->atttypmod,
                          attr->attcollation,
                          0);
 
            tlist = lappend(tlist,
                            makeTargetEntry((Expr *) var,
                                            list_length(tlist) + 1,
                                            NULL,
                                            false));
        }
    }
 
    /* Now add any remaining columns to tlist. */
    foreach(lc, vars)
    {
        Var        *var = (Var *) lfirst(lc);
 
        /*
         * No need for whole-row references to the target relation.  We don't
         * need system columns other than ctid and oid either, since those are
         * set locally.
         */
        if (IsA(var, Var) &&
            var->varno == rtindex &&
            var->varattno <= InvalidAttrNumber &&
            var->varattno != SelfItemPointerAttributeNumber)
            continue;           /* don't need it */
 
        if (tlist_member((Expr *) var, tlist))
            continue;           /* already got it */
 
        tlist = lappend(tlist,
                        makeTargetEntry((Expr *) var,
                                        list_length(tlist) + 1,
                                        NULL,
                                        false));
    }
 
    list_free(vars);
 
    return tlist;
}

References Assert(), 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 void close_cursor	(	PGconn *	conn,
		unsigned int	cursor_number,
		PgFdwConnState *	conn_state
	)

static

Definition at line 3938 of file postgres_fdw.c.

{
    char        sql[64];
    PGresult   *res;
 
    snprintf(sql, sizeof(sql), "CLOSE c%u", cursor_number);
    res = pgfdw_exec_query(conn, sql, conn_state);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pgfdw_report_error(res, conn, sql);
    PQclear(res);
}

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 void complete_pending_request ( AsyncRequest * areq )

static

Definition at line 7457 of file postgres_fdw.c.

{
    /* The request would have been pending for a callback */
    Assert(areq->callback_pending);
 
    /* Unlike AsyncNotify, we unset callback_pending ourselves */
    areq->callback_pending = false;
 
    /* We begin a fetch afterwards if necessary; don't fetch */
    produce_tuple_asynchronously(areq, false);
 
    /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
    ExecAsyncResponse(areq);
 
    /* Also, we do instrumentation ourselves, if required */
    if (areq->requestee->instrument)
        InstrUpdateTupleCount(areq->requestee->instrument,
                              TupIsNull(areq->result) ? 0.0 : 1.0);
}

References Assert(), AsyncRequest::callback_pending, ExecAsyncResponse(), PlanState::instrument, InstrUpdateTupleCount(), produce_tuple_asynchronously(), AsyncRequest::requestee, AsyncRequest::result, and TupIsNull.

Referenced by postgresForeignAsyncConfigureWait().

◆ conversion_error_callback()

static void conversion_error_callback ( void * arg )

static

Definition at line 7648 of file postgres_fdw.c.

{
    ConversionLocation *errpos = (ConversionLocation *) arg;
    Relation    rel = errpos->rel;
    ForeignScanState *fsstate = errpos->fsstate;
    const char *attname = NULL;
    const char *relname = NULL;
    bool        is_wholerow = false;
 
    /*
     * If we're in a scan node, always use aliases from the rangetable, for
     * consistency between the simple-relation and remote-join cases.  Look at
     * the relation's tupdesc only if we're not in a scan node.
     */
    if (fsstate)
    {
        /* ForeignScan case */
        ForeignScan *fsplan = castNode(ForeignScan, fsstate->ss.ps.plan);
        int         varno = 0;
        AttrNumber  colno = 0;
 
        if (fsplan->scan.scanrelid > 0)
        {
            /* error occurred in a scan against a foreign table */
            varno = fsplan->scan.scanrelid;
            colno = errpos->cur_attno;
        }
        else
        {
            /* error occurred in a scan against a foreign join */
            TargetEntry *tle;
 
            tle = list_nth_node(TargetEntry, fsplan->fdw_scan_tlist,
                                errpos->cur_attno - 1);
 
            /*
             * Target list can have Vars and expressions.  For Vars, we can
             * get some information, however for expressions we can't.  Thus
             * for expressions, just show generic context message.
             */
            if (IsA(tle->expr, Var))
            {
                Var        *var = (Var *) tle->expr;
 
                varno = var->varno;
                colno = var->varattno;
            }
        }
 
        if (varno > 0)
        {
            EState     *estate = fsstate->ss.ps.state;
            RangeTblEntry *rte = exec_rt_fetch(varno, estate);
 
            relname = rte->eref->aliasname;
 
            if (colno == 0)
                is_wholerow = true;
            else if (colno > 0 && colno <= list_length(rte->eref->colnames))
                attname = strVal(list_nth(rte->eref->colnames, colno - 1));
            else if (colno == SelfItemPointerAttributeNumber)
                attname = "ctid";
        }
    }
    else if (rel)
    {
        /* Non-ForeignScan case (we should always have a rel here) */
        TupleDesc   tupdesc = RelationGetDescr(rel);
 
        relname = RelationGetRelationName(rel);
        if (errpos->cur_attno > 0 && errpos->cur_attno <= tupdesc->natts)
        {
            Form_pg_attribute attr = TupleDescAttr(tupdesc,
                                                   errpos->cur_attno - 1);
 
            attname = NameStr(attr->attname);
        }
        else if (errpos->cur_attno == SelfItemPointerAttributeNumber)
            attname = "ctid";
    }
 
    if (relname && is_wholerow)
        errcontext("whole-row reference to foreign table \"%s\"", relname);
    else if (relname && attname)
        errcontext("column \"%s\" of foreign table \"%s\"", attname, relname);
    else
        errcontext("processing expression at position %d in select list",
                   errpos->cur_attno);
}

References arg, attname, castNode, ConversionLocation::cur_attno, errcontext, exec_rt_fetch(), TargetEntry::expr, ForeignScan::fdw_scan_tlist, ConversionLocation::fsstate, IsA, list_length(), list_nth(), list_nth_node, NameStr, TupleDescData::natts, PlanState::plan, ScanState::ps, ConversionLocation::rel, RelationGetDescr, RelationGetRelationName, relname, ForeignScan::scan, Scan::scanrelid, SelfItemPointerAttributeNumber, ForeignScanState::ss, PlanState::state, strVal, TupleDescAttr(), Var::varattno, and Var::varno.

Referenced by make_tuple_from_result_row().

◆ convert_prep_stmt_params()

static const char ** convert_prep_stmt_params	(	PgFdwModifyState *	fmstate,
		ItemPointer	tupleid,
		TupleTableSlot **	slots,
		int	numSlots
	)

static

Definition at line 4246 of file postgres_fdw.c.

{
    const char **p_values;
    int         i;
    int         j;
    int         pindex = 0;
    MemoryContext oldcontext;
 
    oldcontext = MemoryContextSwitchTo(fmstate->temp_cxt);
 
    p_values = (const char **) palloc(sizeof(char *) * fmstate->p_nums * numSlots);
 
    /* ctid is provided only for UPDATE/DELETE, which don't allow batching */
    Assert(!(tupleid != NULL && numSlots > 1));
 
    /* 1st parameter should be ctid, if it's in use */
    if (tupleid != NULL)
    {
        Assert(numSlots == 1);
        /* don't need set_transmission_modes for TID output */
        p_values[pindex] = OutputFunctionCall(&fmstate->p_flinfo[pindex],
                                              PointerGetDatum(tupleid));
        pindex++;
    }
 
    /* get following parameters from slots */
    if (slots != NULL && fmstate->target_attrs != NIL)
    {
        TupleDesc   tupdesc = RelationGetDescr(fmstate->rel);
        int         nestlevel;
        ListCell   *lc;
 
        nestlevel = set_transmission_modes();
 
        for (i = 0; i < numSlots; i++)
        {
            j = (tupleid != NULL) ? 1 : 0;
            foreach(lc, fmstate->target_attrs)
            {
                int         attnum = lfirst_int(lc);
                CompactAttribute *attr = TupleDescCompactAttr(tupdesc, attnum - 1);
                Datum       value;
                bool        isnull;
 
                /* Ignore generated columns; they are set to DEFAULT */
                if (attr->attgenerated)
                    continue;
                value = slot_getattr(slots[i], attnum, &isnull);
                if (isnull)
                    p_values[pindex] = NULL;
                else
                    p_values[pindex] = OutputFunctionCall(&fmstate->p_flinfo[j],
                                                          value);
                pindex++;
                j++;
            }
        }
 
        reset_transmission_modes(nestlevel);
    }
 
    Assert(pindex == fmstate->p_nums * numSlots);
 
    MemoryContextSwitchTo(oldcontext);
 
    return p_values;
}

References Assert(), CompactAttribute::attgenerated, attnum, i, j, lfirst_int, MemoryContextSwitchTo(), NIL, OutputFunctionCall(), PgFdwModifyState::p_flinfo, PgFdwModifyState::p_nums, palloc(), PointerGetDatum(), PgFdwModifyState::rel, RelationGetDescr, reset_transmission_modes(), set_transmission_modes(), slot_getattr(), PgFdwModifyState::target_attrs, PgFdwModifyState::temp_cxt, TupleDescCompactAttr(), and value.

Referenced by execute_foreign_modify().

◆ create_cursor()

static void create_cursor ( ForeignScanState * node )

static

Definition at line 3725 of file postgres_fdw.c.

{
    PgFdwScanState *fsstate = (PgFdwScanState *) node->fdw_state;
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
    int         numParams = fsstate->numParams;
    const char **values = fsstate->param_values;
    PGconn     *conn = fsstate->conn;
    StringInfoData buf;
    PGresult   *res;
 
    /* First, process a pending asynchronous request, if any. */
    if (fsstate->conn_state->pendingAreq)
        process_pending_request(fsstate->conn_state->pendingAreq);
 
    /*
     * Construct array of query parameter values in text format.  We do the
     * conversions in the short-lived per-tuple context, so as not to cause a
     * memory leak over repeated scans.
     */
    if (numParams > 0)
    {
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
 
        process_query_params(econtext,
                             fsstate->param_flinfo,
                             fsstate->param_exprs,
                             values);
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    /* Construct the DECLARE CURSOR command */
    initStringInfo(&buf);
    appendStringInfo(&buf, "DECLARE c%u CURSOR FOR\n%s",
                     fsstate->cursor_number, fsstate->query);
 
    /*
     * Notice that we pass NULL for paramTypes, thus forcing the remote server
     * to infer types for all parameters.  Since we explicitly cast every
     * parameter (see deparse.c), the "inference" is trivial and will produce
     * the desired result.  This allows us to avoid assuming that the remote
     * server has the same OIDs we do for the parameters' types.
     */
    if (!PQsendQueryParams(conn, buf.data, numParams,
                           NULL, values, NULL, NULL, 0))
        pgfdw_report_error(NULL, conn, buf.data);
 
    /*
     * Get the result, and check for success.
     */
    res = pgfdw_get_result(conn);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pgfdw_report_error(res, conn, fsstate->query);
    PQclear(res);
 
    /* Mark the cursor as created, and show no tuples have been retrieved */
    fsstate->cursor_exists = true;
    fsstate->tuples = NULL;
    fsstate->num_tuples = 0;
    fsstate->next_tuple = 0;
    fsstate->fetch_ct_2 = 0;
    fsstate->eof_reached = false;
 
    /* Clean up */
    pfree(buf.data);
}

References appendStringInfo(), buf, PgFdwScanState::conn, conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_exists, PgFdwScanState::cursor_number, PgFdwScanState::eof_reached, ForeignScanState::fdw_state, PgFdwScanState::fetch_ct_2, if(), 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 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
	)

static

Definition at line 3957 of file postgres_fdw.c.

{
    PgFdwModifyState *fmstate;
    Relation    rel = resultRelInfo->ri_RelationDesc;
    TupleDesc   tupdesc = RelationGetDescr(rel);
    Oid         userid;
    ForeignTable *table;
    UserMapping *user;
    AttrNumber  n_params;
    Oid         typefnoid;
    bool        isvarlena;
    ListCell   *lc;
 
    /* Begin constructing PgFdwModifyState. */
    fmstate = (PgFdwModifyState *) palloc0(sizeof(PgFdwModifyState));
    fmstate->rel = rel;
 
    /* Identify which user to do the remote access as. */
    userid = ExecGetResultRelCheckAsUser(resultRelInfo, estate);
 
    /* Get info about foreign table. */
    table = GetForeignTable(RelationGetRelid(rel));
    user = GetUserMapping(userid, table->serverid);
 
    /* Open connection; report that we'll create a prepared statement. */
    fmstate->conn = GetConnection(user, true, &fmstate->conn_state);
    fmstate->p_name = NULL;     /* prepared statement not made yet */
 
    /* Set up remote query information. */
    fmstate->query = query;
    if (operation == CMD_INSERT)
    {
        fmstate->query = pstrdup(fmstate->query);
        fmstate->orig_query = pstrdup(fmstate->query);
    }
    fmstate->target_attrs = target_attrs;
    fmstate->values_end = values_end;
    fmstate->has_returning = has_returning;
    fmstate->retrieved_attrs = retrieved_attrs;
 
    /* Create context for per-tuple temp workspace. */
    fmstate->temp_cxt = AllocSetContextCreate(estate->es_query_cxt,
                                              "postgres_fdw temporary data",
                                              ALLOCSET_SMALL_SIZES);
 
    /* Prepare for input conversion of RETURNING results. */
    if (fmstate->has_returning)
        fmstate->attinmeta = TupleDescGetAttInMetadata(tupdesc);
 
    /* Prepare for output conversion of parameters used in prepared stmt. */
    n_params = list_length(fmstate->target_attrs) + 1;
    fmstate->p_flinfo = (FmgrInfo *) palloc0(sizeof(FmgrInfo) * n_params);
    fmstate->p_nums = 0;
 
    if (operation == CMD_UPDATE || operation == CMD_DELETE)
    {
        Assert(subplan != NULL);
 
        /* Find the ctid resjunk column in the subplan's result */
        fmstate->ctidAttno = ExecFindJunkAttributeInTlist(subplan->targetlist,
                                                          "ctid");
        if (!AttributeNumberIsValid(fmstate->ctidAttno))
            elog(ERROR, "could not find junk ctid column");
 
        /* First transmittable parameter will be ctid */
        getTypeOutputInfo(TIDOID, &typefnoid, &isvarlena);
        fmgr_info(typefnoid, &fmstate->p_flinfo[fmstate->p_nums]);
        fmstate->p_nums++;
    }
 
    if (operation == CMD_INSERT || operation == CMD_UPDATE)
    {
        /* Set up for remaining transmittable parameters */
        foreach(lc, fmstate->target_attrs)
        {
            int         attnum = lfirst_int(lc);
            Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
 
            Assert(!attr->attisdropped);
 
            /* Ignore generated columns; they are set to DEFAULT */
            if (attr->attgenerated)
                continue;
            getTypeOutputInfo(attr->atttypid, &typefnoid, &isvarlena);
            fmgr_info(typefnoid, &fmstate->p_flinfo[fmstate->p_nums]);
            fmstate->p_nums++;
        }
    }
 
    Assert(fmstate->p_nums <= n_params);
 
    /* Set batch_size from foreign server/table options. */
    if (operation == CMD_INSERT)
        fmstate->batch_size = get_batch_size_option(rel);
 
    fmstate->num_slots = 1;
 
    /* Initialize auxiliary state */
    fmstate->aux_fmstate = NULL;
 
    return fmstate;
}

Referenced by postgresBeginForeignInsert(), and postgresBeginForeignModify().

◆ deallocate_query()

static void deallocate_query ( PgFdwModifyState * fmstate )

static

Definition at line 4364 of file postgres_fdw.c.

{
    char        sql[64];
    PGresult   *res;
 
    /* do nothing if the query is not allocated */
    if (!fmstate->p_name)
        return;
 
    snprintf(sql, sizeof(sql), "DEALLOCATE %s", fmstate->p_name);
    res = pgfdw_exec_query(fmstate->conn, sql, fmstate->conn_state);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pgfdw_report_error(res, fmstate->conn, sql);
    PQclear(res);
    pfree(fmstate->p_name);
    fmstate->p_name = NULL;
}

References PgFdwModifyState::conn, PgFdwModifyState::conn_state, PgFdwModifyState::p_name, 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 bool ec_member_matches_foreign	(	PlannerInfo *	root,
		RelOptInfo *	rel,
		EquivalenceClass *	ec,
		EquivalenceMember *	em,
		void *	arg
	)

static

Definition at line 3696 of file postgres_fdw.c.

{
    ec_member_foreign_arg *state = (ec_member_foreign_arg *) arg;
    Expr       *expr = em->em_expr;
 
    /*
     * If we've identified what we're processing in the current scan, we only
     * want to match that expression.
     */
    if (state->current != NULL)
        return equal(expr, state->current);
 
    /*
     * Otherwise, ignore anything we've already processed.
     */
    if (list_member(state->already_used, expr))
        return false;
 
    /* This is the new target to process. */
    state->current = expr;
    return true;
}

References arg, EquivalenceMember::em_expr, equal(), and list_member().

Referenced by postgresGetForeignPaths().

◆ estimate_path_cost_size()

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
	)

static

Definition at line 3089 of file postgres_fdw.c.

{
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
    double      rows;
    double      retrieved_rows;
    int         width;
    int         disabled_nodes = 0;
    Cost        startup_cost;
    Cost        total_cost;
 
    /* Make sure the core code has set up the relation's reltarget */
    Assert(foreignrel->reltarget);
 
    /*
     * If the table or the server is configured to use remote estimates,
     * connect to the foreign server and execute EXPLAIN to estimate the
     * number of rows selected by the restriction+join clauses.  Otherwise,
     * estimate rows using whatever statistics we have locally, in a way
     * similar to ordinary tables.
     */
    if (fpinfo->use_remote_estimate)
    {
        List       *remote_param_join_conds;
        List       *local_param_join_conds;
        StringInfoData sql;
        PGconn     *conn;
        Selectivity local_sel;
        QualCost    local_cost;
        List       *fdw_scan_tlist = NIL;
        List       *remote_conds;
 
        /* Required only to be passed to deparseSelectStmtForRel */
        List       *retrieved_attrs;
 
        /*
         * param_join_conds might contain both clauses that are safe to send
         * across, and clauses that aren't.
         */
        classifyConditions(root, foreignrel, param_join_conds,
                           &remote_param_join_conds, &local_param_join_conds);
 
        /* Build the list of columns to be fetched from the foreign server. */
        if (IS_JOIN_REL(foreignrel) || IS_UPPER_REL(foreignrel))
            fdw_scan_tlist = build_tlist_to_deparse(foreignrel);
        else
            fdw_scan_tlist = NIL;
 
        /*
         * The complete list of remote conditions includes everything from
         * baserestrictinfo plus any extra join_conds relevant to this
         * particular path.
         */
        remote_conds = list_concat(remote_param_join_conds,
                                   fpinfo->remote_conds);
 
        /*
         * Construct EXPLAIN query including the desired SELECT, FROM, and
         * WHERE clauses. Params and other-relation Vars are replaced by dummy
         * values, so don't request params_list.
         */
        initStringInfo(&sql);
        appendStringInfoString(&sql, "EXPLAIN ");
        deparseSelectStmtForRel(&sql, root, foreignrel, fdw_scan_tlist,
                                remote_conds, pathkeys,
                                fpextra ? fpextra->has_final_sort : false,
                                fpextra ? fpextra->has_limit : false,
                                false, &retrieved_attrs, NULL);
 
        /* Get the remote estimate */
        conn = GetConnection(fpinfo->user, false, NULL);
        get_remote_estimate(sql.data, conn, &rows, &width,
                            &startup_cost, &total_cost);
        ReleaseConnection(conn);
 
        retrieved_rows = rows;
 
        /* Factor in the selectivity of the locally-checked quals */
        local_sel = clauselist_selectivity(root,
                                           local_param_join_conds,
                                           foreignrel->relid,
                                           JOIN_INNER,
                                           NULL);
        local_sel *= fpinfo->local_conds_sel;
 
        rows = clamp_row_est(rows * local_sel);
 
        /* Add in the eval cost of the locally-checked quals */
        startup_cost += fpinfo->local_conds_cost.startup;
        total_cost += fpinfo->local_conds_cost.per_tuple * retrieved_rows;
        cost_qual_eval(&local_cost, local_param_join_conds, root);
        startup_cost += local_cost.startup;
        total_cost += local_cost.per_tuple * retrieved_rows;
 
        /*
         * Add in tlist eval cost for each output row.  In case of an
         * aggregate, some of the tlist expressions such as grouping
         * expressions will be evaluated remotely, so adjust the costs.
         */
        startup_cost += foreignrel->reltarget->cost.startup;
        total_cost += foreignrel->reltarget->cost.startup;
        total_cost += foreignrel->reltarget->cost.per_tuple * rows;
        if (IS_UPPER_REL(foreignrel))
        {
            QualCost    tlist_cost;
 
            cost_qual_eval(&tlist_cost, fdw_scan_tlist, root);
            startup_cost -= tlist_cost.startup;
            total_cost -= tlist_cost.startup;
            total_cost -= tlist_cost.per_tuple * rows;
        }
    }
    else
    {
        Cost        run_cost = 0;
 
        /*
         * We don't support join conditions in this mode (hence, no
         * parameterized paths can be made).
         */
        Assert(param_join_conds == NIL);
 
        /*
         * We will come here again and again with different set of pathkeys or
         * additional post-scan/join-processing steps that caller wants to
         * cost.  We don't need to calculate the cost/size estimates for the
         * underlying scan, join, or grouping each time.  Instead, use those
         * estimates if we have cached them already.
         */
        if (fpinfo->rel_startup_cost >= 0 && fpinfo->rel_total_cost >= 0)
        {
            Assert(fpinfo->retrieved_rows >= 0);
 
            rows = fpinfo->rows;
            retrieved_rows = fpinfo->retrieved_rows;
            width = fpinfo->width;
            startup_cost = fpinfo->rel_startup_cost;
            run_cost = fpinfo->rel_total_cost - fpinfo->rel_startup_cost;
 
            /*
             * If we estimate the costs of a foreign scan or a foreign join
             * with additional post-scan/join-processing steps, the scan or
             * join costs obtained from the cache wouldn't yet contain the
             * eval costs for the final scan/join target, which would've been
             * updated by apply_scanjoin_target_to_paths(); add the eval costs
             * now.
             */
            if (fpextra && !IS_UPPER_REL(foreignrel))
            {
                /* Shouldn't get here unless we have LIMIT */
                Assert(fpextra->has_limit);
                Assert(foreignrel->reloptkind == RELOPT_BASEREL ||
                       foreignrel->reloptkind == RELOPT_JOINREL);
                startup_cost += foreignrel->reltarget->cost.startup;
                run_cost += foreignrel->reltarget->cost.per_tuple * rows;
            }
        }
        else if (IS_JOIN_REL(foreignrel))
        {
            PgFdwRelationInfo *fpinfo_i;
            PgFdwRelationInfo *fpinfo_o;
            QualCost    join_cost;
            QualCost    remote_conds_cost;
            double      nrows;
 
            /* Use rows/width estimates made by the core code. */
            rows = foreignrel->rows;
            width = foreignrel->reltarget->width;
 
            /* For join we expect inner and outer relations set */
            Assert(fpinfo->innerrel && fpinfo->outerrel);
 
            fpinfo_i = (PgFdwRelationInfo *) fpinfo->innerrel->fdw_private;
            fpinfo_o = (PgFdwRelationInfo *) fpinfo->outerrel->fdw_private;
 
            /* Estimate of number of rows in cross product */
            nrows = fpinfo_i->rows * fpinfo_o->rows;
 
            /*
             * Back into an estimate of the number of retrieved rows.  Just in
             * case this is nuts, clamp to at most nrows.
             */
            retrieved_rows = clamp_row_est(rows / fpinfo->local_conds_sel);
            retrieved_rows = Min(retrieved_rows, nrows);
 
            /*
             * The cost of foreign join is estimated as cost of generating
             * rows for the joining relations + cost for applying quals on the
             * rows.
             */
 
            /*
             * Calculate the cost of clauses pushed down to the foreign server
             */
            cost_qual_eval(&remote_conds_cost, fpinfo->remote_conds, root);
            /* Calculate the cost of applying join clauses */
            cost_qual_eval(&join_cost, fpinfo->joinclauses, root);
 
            /*
             * Startup cost includes startup cost of joining relations and the
             * startup cost for join and other clauses. We do not include the
             * startup cost specific to join strategy (e.g. setting up hash
             * tables) since we do not know what strategy the foreign server
             * is going to use.
             */
            startup_cost = fpinfo_i->rel_startup_cost + fpinfo_o->rel_startup_cost;
            startup_cost += join_cost.startup;
            startup_cost += remote_conds_cost.startup;
            startup_cost += fpinfo->local_conds_cost.startup;
 
            /*
             * Run time cost includes:
             *
             * 1. Run time cost (total_cost - startup_cost) of relations being
             * joined
             *
             * 2. Run time cost of applying join clauses on the cross product
             * of the joining relations.
             *
             * 3. Run time cost of applying pushed down other clauses on the
             * result of join
             *
             * 4. Run time cost of applying nonpushable other clauses locally
             * on the result fetched from the foreign server.
             */
            run_cost = fpinfo_i->rel_total_cost - fpinfo_i->rel_startup_cost;
            run_cost += fpinfo_o->rel_total_cost - fpinfo_o->rel_startup_cost;
            run_cost += nrows * join_cost.per_tuple;
            nrows = clamp_row_est(nrows * fpinfo->joinclause_sel);
            run_cost += nrows * remote_conds_cost.per_tuple;
            run_cost += fpinfo->local_conds_cost.per_tuple * retrieved_rows;
 
            /* Add in tlist eval cost for each output row */
            startup_cost += foreignrel->reltarget->cost.startup;
            run_cost += foreignrel->reltarget->cost.per_tuple * rows;
        }
        else if (IS_UPPER_REL(foreignrel))
        {
            RelOptInfo *outerrel = fpinfo->outerrel;
            PgFdwRelationInfo *ofpinfo;
            AggClauseCosts aggcosts = {0};
            double      input_rows;
            int         numGroupCols;
            double      numGroups = 1;
 
            /* The upper relation should have its outer relation set */
            Assert(outerrel);
            /* and that outer relation should have its reltarget set */
            Assert(outerrel->reltarget);
 
            /*
             * This cost model is mixture of costing done for sorted and
             * hashed aggregates in cost_agg().  We are not sure which
             * strategy will be considered at remote side, thus for
             * simplicity, we put all startup related costs in startup_cost
             * and all finalization and run cost are added in total_cost.
             */
 
            ofpinfo = (PgFdwRelationInfo *) outerrel->fdw_private;
 
            /* Get rows from input rel */
            input_rows = ofpinfo->rows;
 
            /* Collect statistics about aggregates for estimating costs. */
            if (root->parse->hasAggs)
            {
                get_agg_clause_costs(root, AGGSPLIT_SIMPLE, &aggcosts);
            }
 
            /* Get number of grouping columns and possible number of groups */
            numGroupCols = list_length(root->processed_groupClause);
            numGroups = estimate_num_groups(root,
                                            get_sortgrouplist_exprs(root->processed_groupClause,
                                                                    fpinfo->grouped_tlist),
                                            input_rows, NULL, NULL);
 
            /*
             * Get the retrieved_rows and rows estimates.  If there are HAVING
             * quals, account for their selectivity.
             */
            if (root->hasHavingQual)
            {
                /* Factor in the selectivity of the remotely-checked quals */
                retrieved_rows =
                    clamp_row_est(numGroups *
                                  clauselist_selectivity(root,
                                                         fpinfo->remote_conds,
                                                         0,
                                                         JOIN_INNER,
                                                         NULL));
                /* Factor in the selectivity of the locally-checked quals */
                rows = clamp_row_est(retrieved_rows * fpinfo->local_conds_sel);
            }
            else
            {
                rows = retrieved_rows = numGroups;
            }
 
            /* Use width estimate made by the core code. */
            width = foreignrel->reltarget->width;
 
            /*-----
             * Startup cost includes:
             *    1. Startup cost for underneath input relation, adjusted for
             *       tlist replacement by apply_scanjoin_target_to_paths()
             *    2. Cost of performing aggregation, per cost_agg()
             *-----
             */
            startup_cost = ofpinfo->rel_startup_cost;
            startup_cost += outerrel->reltarget->cost.startup;
            startup_cost += aggcosts.transCost.startup;
            startup_cost += aggcosts.transCost.per_tuple * input_rows;
            startup_cost += aggcosts.finalCost.startup;
            startup_cost += (cpu_operator_cost * numGroupCols) * input_rows;
 
            /*-----
             * Run time cost includes:
             *    1. Run time cost of underneath input relation, adjusted for
             *       tlist replacement by apply_scanjoin_target_to_paths()
             *    2. Run time cost of performing aggregation, per cost_agg()
             *-----
             */
            run_cost = ofpinfo->rel_total_cost - ofpinfo->rel_startup_cost;
            run_cost += outerrel->reltarget->cost.per_tuple * input_rows;
            run_cost += aggcosts.finalCost.per_tuple * numGroups;
            run_cost += cpu_tuple_cost * numGroups;
 
            /* Account for the eval cost of HAVING quals, if any */
            if (root->hasHavingQual)
            {
                QualCost    remote_cost;
 
                /* Add in the eval cost of the remotely-checked quals */
                cost_qual_eval(&remote_cost, fpinfo->remote_conds, root);
                startup_cost += remote_cost.startup;
                run_cost += remote_cost.per_tuple * numGroups;
                /* Add in the eval cost of the locally-checked quals */
                startup_cost += fpinfo->local_conds_cost.startup;
                run_cost += fpinfo->local_conds_cost.per_tuple * retrieved_rows;
            }
 
            /* Add in tlist eval cost for each output row */
            startup_cost += foreignrel->reltarget->cost.startup;
            run_cost += foreignrel->reltarget->cost.per_tuple * rows;
        }
        else
        {
            Cost        cpu_per_tuple;
 
            /* Use rows/width estimates made by set_baserel_size_estimates. */
            rows = foreignrel->rows;
            width = foreignrel->reltarget->width;
 
            /*
             * Back into an estimate of the number of retrieved rows.  Just in
             * case this is nuts, clamp to at most foreignrel->tuples.
             */
            retrieved_rows = clamp_row_est(rows / fpinfo->local_conds_sel);
            retrieved_rows = Min(retrieved_rows, foreignrel->tuples);
 
            /*
             * Cost as though this were a seqscan, which is pessimistic.  We
             * effectively imagine the local_conds are being evaluated
             * remotely, too.
             */
            startup_cost = 0;
            run_cost = 0;
            run_cost += seq_page_cost * foreignrel->pages;
 
            startup_cost += foreignrel->baserestrictcost.startup;
            cpu_per_tuple = cpu_tuple_cost + foreignrel->baserestrictcost.per_tuple;
            run_cost += cpu_per_tuple * foreignrel->tuples;
 
            /* Add in tlist eval cost for each output row */
            startup_cost += foreignrel->reltarget->cost.startup;
            run_cost += foreignrel->reltarget->cost.per_tuple * rows;
        }
 
        /*
         * Without remote estimates, we have no real way to estimate the cost
         * of generating sorted output.  It could be free if the query plan
         * the remote side would have chosen generates properly-sorted output
         * anyway, but in most cases it will cost something.  Estimate a value
         * high enough that we won't pick the sorted path when the ordering
         * isn't locally useful, but low enough that we'll err on the side of
         * pushing down the ORDER BY clause when it's useful to do so.
         */
        if (pathkeys != NIL)
        {
            if (IS_UPPER_REL(foreignrel))
            {
                Assert(foreignrel->reloptkind == RELOPT_UPPER_REL &&
                       fpinfo->stage == UPPERREL_GROUP_AGG);
 
                /*
                 * We can only get here when this function is called from
                 * add_foreign_ordered_paths() or add_foreign_final_paths();
                 * in which cases, the passed-in fpextra should not be NULL.
                 */
                Assert(fpextra);
                adjust_foreign_grouping_path_cost(root, pathkeys,
                                                  retrieved_rows, width,
                                                  fpextra->limit_tuples,
                                                  &disabled_nodes,
                                                  &startup_cost, &run_cost);
            }
            else
            {
                startup_cost *= DEFAULT_FDW_SORT_MULTIPLIER;
                run_cost *= DEFAULT_FDW_SORT_MULTIPLIER;
            }
        }
 
        total_cost = startup_cost + run_cost;
 
        /* Adjust the cost estimates if we have LIMIT */
        if (fpextra && fpextra->has_limit)
        {
            adjust_limit_rows_costs(&rows, &startup_cost, &total_cost,
                                    fpextra->offset_est, fpextra->count_est);
            retrieved_rows = rows;
        }
    }
 
    /*
     * If this includes the final sort step, the given target, which will be
     * applied to the resulting path, might have different expressions from
     * the foreignrel's reltarget (see make_sort_input_target()); adjust tlist
     * eval costs.
     */
    if (fpextra && fpextra->has_final_sort &&
        fpextra->target != foreignrel->reltarget)
    {
        QualCost    oldcost = foreignrel->reltarget->cost;
        QualCost    newcost = fpextra->target->cost;
 
        startup_cost += newcost.startup - oldcost.startup;
        total_cost += newcost.startup - oldcost.startup;
        total_cost += (newcost.per_tuple - oldcost.per_tuple) * rows;
    }
 
    /*
     * Cache the retrieved rows and cost estimates for scans, joins, or
     * groupings without any parameterization, pathkeys, or additional
     * post-scan/join-processing steps, before adding the costs for
     * transferring data from the foreign server.  These estimates are useful
     * for costing remote joins involving this relation or costing other
     * remote operations on this relation such as remote sorts and remote
     * LIMIT restrictions, when the costs can not be obtained from the foreign
     * server.  This function will be called at least once for every foreign
     * relation without any parameterization, pathkeys, or additional
     * post-scan/join-processing steps.
     */
    if (pathkeys == NIL && param_join_conds == NIL && fpextra == NULL)
    {
        fpinfo->retrieved_rows = retrieved_rows;
        fpinfo->rel_startup_cost = startup_cost;
        fpinfo->rel_total_cost = total_cost;
    }
 
    /*
     * Add some additional cost factors to account for connection overhead
     * (fdw_startup_cost), transferring data across the network
     * (fdw_tuple_cost per retrieved row), and local manipulation of the data
     * (cpu_tuple_cost per retrieved row).
     */
    startup_cost += fpinfo->fdw_startup_cost;
    total_cost += fpinfo->fdw_startup_cost;
    total_cost += fpinfo->fdw_tuple_cost * retrieved_rows;
    total_cost += cpu_tuple_cost * retrieved_rows;
 
    /*
     * If we have LIMIT, we should prefer performing the restriction remotely
     * rather than locally, as the former avoids extra row fetches from the
     * remote that the latter might cause.  But since the core code doesn't
     * account for such fetches when estimating the costs of the local
     * restriction (see create_limit_path()), there would be no difference
     * between the costs of the local restriction and the costs of the remote
     * restriction estimated above if we don't use remote estimates (except
     * for the case where the foreignrel is a grouping relation, the given
     * pathkeys is not NIL, and the effects of a bounded sort for that rel is
     * accounted for in costing the remote restriction).  Tweak the costs of
     * the remote restriction to ensure we'll prefer it if LIMIT is a useful
     * one.
     */
    if (!fpinfo->use_remote_estimate &&
        fpextra && fpextra->has_limit &&
        fpextra->limit_tuples > 0 &&
        fpextra->limit_tuples < fpinfo->rows)
    {
        Assert(fpinfo->rows > 0);
        total_cost -= (total_cost - startup_cost) * 0.05 *
            (fpinfo->rows - fpextra->limit_tuples) / fpinfo->rows;
    }
 
    /* Return results. */
    *p_rows = rows;
    *p_width = width;
    *p_disabled_nodes = disabled_nodes;
    *p_startup_cost = startup_cost;
    *p_total_cost = total_cost;
}

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 void execute_dml_stmt ( ForeignScanState * node )

static

Definition at line 4515 of file postgres_fdw.c.

{
    PgFdwDirectModifyState *dmstate = (PgFdwDirectModifyState *) node->fdw_state;
    ExprContext *econtext = node->ss.ps.ps_ExprContext;
    int         numParams = dmstate->numParams;
    const char **values = dmstate->param_values;
 
    /* First, process a pending asynchronous request, if any. */
    if (dmstate->conn_state->pendingAreq)
        process_pending_request(dmstate->conn_state->pendingAreq);
 
    /*
     * Construct array of query parameter values in text format.
     */
    if (numParams > 0)
        process_query_params(econtext,
                             dmstate->param_flinfo,
                             dmstate->param_exprs,
                             values);
 
    /*
     * Notice that we pass NULL for paramTypes, thus forcing the remote server
     * to infer types for all parameters.  Since we explicitly cast every
     * parameter (see deparse.c), the "inference" is trivial and will produce
     * the desired result.  This allows us to avoid assuming that the remote
     * server has the same OIDs we do for the parameters' types.
     */
    if (!PQsendQueryParams(dmstate->conn, dmstate->query, numParams,
                           NULL, values, NULL, NULL, 0))
        pgfdw_report_error(NULL, dmstate->conn, dmstate->query);
 
    /*
     * Get the result, and check for success.
     */
    dmstate->result = pgfdw_get_result(dmstate->conn);
    if (PQresultStatus(dmstate->result) !=
        (dmstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
        pgfdw_report_error(dmstate->result, dmstate->conn,
                           dmstate->query);
 
    /*
     * The result potentially needs to survive across multiple executor row
     * cycles, so move it to the context where the dmstate is.
     */
    dmstate->result = libpqsrv_PGresultSetParent(dmstate->result,
                                                 GetMemoryChunkContext(dmstate));
 
    /* Get the number of rows affected. */
    if (dmstate->has_returning)
        dmstate->num_tuples = PQntuples(dmstate->result);
    else
        dmstate->num_tuples = atoi(PQcmdTuples(dmstate->result));
}

Referenced by postgresIterateDirectModify().

◆ execute_foreign_modify()

static TupleTableSlot ** execute_foreign_modify	(	EState *	estate,
		ResultRelInfo *	resultRelInfo,
		CmdType	operation,
		TupleTableSlot **	slots,
		TupleTableSlot **	planSlots,
		int *	numSlots
	)

static

Definition at line 4077 of file postgres_fdw.c.

{
    PgFdwModifyState *fmstate = (PgFdwModifyState *) resultRelInfo->ri_FdwState;
    ItemPointer ctid = NULL;
    const char **p_values;
    PGresult   *res;
    int         n_rows;
    StringInfoData sql;
 
    /* The operation should be INSERT, UPDATE, or DELETE */
    Assert(operation == CMD_INSERT ||
           operation == CMD_UPDATE ||
           operation == CMD_DELETE);
 
    /* First, process a pending asynchronous request, if any. */
    if (fmstate->conn_state->pendingAreq)
        process_pending_request(fmstate->conn_state->pendingAreq);
 
    /*
     * If the existing query was deparsed and prepared for a different number
     * of rows, rebuild it for the proper number.
     */
    if (operation == CMD_INSERT && fmstate->num_slots != *numSlots)
    {
        /* Destroy the prepared statement created previously */
        if (fmstate->p_name)
            deallocate_query(fmstate);
 
        /* Build INSERT string with numSlots records in its VALUES clause. */
        initStringInfo(&sql);
        rebuildInsertSql(&sql, fmstate->rel,
                         fmstate->orig_query, fmstate->target_attrs,
                         fmstate->values_end, fmstate->p_nums,
                         *numSlots - 1);
        pfree(fmstate->query);
        fmstate->query = sql.data;
        fmstate->num_slots = *numSlots;
    }
 
    /* Set up the prepared statement on the remote server, if we didn't yet */
    if (!fmstate->p_name)
        prepare_foreign_modify(fmstate);
 
    /*
     * For UPDATE/DELETE, get the ctid that was passed up as a resjunk column
     */
    if (operation == CMD_UPDATE || operation == CMD_DELETE)
    {
        Datum       datum;
        bool        isNull;
 
        datum = ExecGetJunkAttribute(planSlots[0],
                                     fmstate->ctidAttno,
                                     &isNull);
        /* shouldn't ever get a null result... */
        if (isNull)
            elog(ERROR, "ctid is NULL");
        ctid = (ItemPointer) DatumGetPointer(datum);
    }
 
    /* Convert parameters needed by prepared statement to text form */
    p_values = convert_prep_stmt_params(fmstate, ctid, slots, *numSlots);
 
    /*
     * Execute the prepared statement.
     */
    if (!PQsendQueryPrepared(fmstate->conn,
                             fmstate->p_name,
                             fmstate->p_nums * (*numSlots),
                             p_values,
                             NULL,
                             NULL,
                             0))
        pgfdw_report_error(NULL, fmstate->conn, fmstate->query);
 
    /*
     * Get the result, and check for success.
     */
    res = pgfdw_get_result(fmstate->conn);
    if (PQresultStatus(res) !=
        (fmstate->has_returning ? PGRES_TUPLES_OK : PGRES_COMMAND_OK))
        pgfdw_report_error(res, fmstate->conn, fmstate->query);
 
    /* Check number of rows affected, and fetch RETURNING tuple if any */
    if (fmstate->has_returning)
    {
        Assert(*numSlots == 1);
        n_rows = PQntuples(res);
        if (n_rows > 0)
            store_returning_result(fmstate, slots[0], res);
    }
    else
        n_rows = atoi(PQcmdTuples(res));
 
    /* And clean up */
    PQclear(res);
 
    MemoryContextReset(fmstate->temp_cxt);
 
    *numSlots = n_rows;
 
    /*
     * Return NULL if nothing was inserted/updated/deleted on the remote end
     */
    return (n_rows > 0) ? slots : NULL;
}

Referenced by postgresExecForeignBatchInsert(), postgresExecForeignDelete(), postgresExecForeignInsert(), and postgresExecForeignUpdate().

◆ fetch_more_data()

static void fetch_more_data ( ForeignScanState * node )

static

Definition at line 3798 of file postgres_fdw.c.

{
    PgFdwScanState *fsstate = (PgFdwScanState *) node->fdw_state;
    PGconn     *conn = fsstate->conn;
    PGresult   *res;
    int         numrows;
    int         i;
    MemoryContext oldcontext;
 
    /*
     * We'll store the tuples in the batch_cxt.  First, flush the previous
     * batch.
     */
    fsstate->tuples = NULL;
    MemoryContextReset(fsstate->batch_cxt);
    oldcontext = MemoryContextSwitchTo(fsstate->batch_cxt);
 
    if (fsstate->async_capable)
    {
        Assert(fsstate->conn_state->pendingAreq);
 
        /*
         * The query was already sent by an earlier call to
         * fetch_more_data_begin.  So now we just fetch the result.
         */
        res = pgfdw_get_result(conn);
        /* On error, report the original query, not the FETCH. */
        if (PQresultStatus(res) != PGRES_TUPLES_OK)
            pgfdw_report_error(res, conn, fsstate->query);
 
        /* Reset per-connection state */
        fsstate->conn_state->pendingAreq = NULL;
    }
    else
    {
        char        sql[64];
 
        /* This is a regular synchronous fetch. */
        snprintf(sql, sizeof(sql), "FETCH %d FROM c%u",
                 fsstate->fetch_size, fsstate->cursor_number);
 
        res = pgfdw_exec_query(conn, sql, fsstate->conn_state);
        /* On error, report the original query, not the FETCH. */
        if (PQresultStatus(res) != PGRES_TUPLES_OK)
            pgfdw_report_error(res, conn, fsstate->query);
    }
 
    /* Convert the data into HeapTuples */
    numrows = PQntuples(res);
    fsstate->tuples = (HeapTuple *) palloc0(numrows * sizeof(HeapTuple));
    fsstate->num_tuples = numrows;
    fsstate->next_tuple = 0;
 
    for (i = 0; i < numrows; i++)
    {
        Assert(IsA(node->ss.ps.plan, ForeignScan));
 
        fsstate->tuples[i] =
            make_tuple_from_result_row(res, i,
                                       fsstate->rel,
                                       fsstate->attinmeta,
                                       fsstate->retrieved_attrs,
                                       node,
                                       fsstate->temp_cxt);
    }
 
    /* Update fetch_ct_2 */
    if (fsstate->fetch_ct_2 < 2)
        fsstate->fetch_ct_2++;
 
    /* Must be EOF if we didn't get as many tuples as we asked for. */
    fsstate->eof_reached = (numrows < fsstate->fetch_size);
 
    PQclear(res);
 
    MemoryContextSwitchTo(oldcontext);
}

References Assert(), PgFdwScanState::async_capable, PgFdwScanState::attinmeta, PgFdwScanState::batch_cxt, PgFdwScanState::conn, conn, PgFdwScanState::conn_state, PgFdwScanState::cursor_number, PgFdwScanState::eof_reached, 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 void fetch_more_data_begin ( AsyncRequest * areq )

static

Definition at line 7397 of file postgres_fdw.c.

{
    ForeignScanState *node = (ForeignScanState *) areq->requestee;
    PgFdwScanState *fsstate = (PgFdwScanState *) node->fdw_state;
    char        sql[64];
 
    Assert(!fsstate->conn_state->pendingAreq);
 
    /* Create the cursor synchronously. */
    if (!fsstate->cursor_exists)
        create_cursor(node);
 
    /* We will send this query, but not wait for the response. */
    snprintf(sql, sizeof(sql), "FETCH %d FROM c%u",
             fsstate->fetch_size, fsstate->cursor_number);
 
    if (!PQsendQuery(fsstate->conn, sql))
        pgfdw_report_error(NULL, fsstate->conn, fsstate->query);
 
    /* Remember that the request is in process */
    fsstate->conn_state->pendingAreq = areq;
}

References Assert(), create_cursor(), ForeignScanState::fdw_state, pgfdw_report_error(), PQsendQuery(), AsyncRequest::requestee, 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.

{
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) rel->fdw_private;
    EquivalenceMemberIterator it;
    EquivalenceMember *em;
 
    setup_eclass_member_iterator(&it, ec, rel->relids);
    while ((em = eclass_member_iterator_next(&it)) != NULL)
    {
        /*
         * Note we require !bms_is_empty, else we'd accept constant
         * expressions which are not suitable for the purpose.
         */
        if (bms_is_subset(em->em_relids, rel->relids) &&
            !bms_is_empty(em->em_relids) &&
            bms_is_empty(bms_intersect(em->em_relids, fpinfo->hidden_subquery_rels)) &&
            is_foreign_expr(root, rel, em->em_expr))
            return em;
    }
 
    return NULL;
}

References bms_intersect(), bms_is_empty, bms_is_subset(), eclass_member_iterator_next(), PgFdwRelationInfo::hidden_subquery_rels, 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.

{
    PathTarget *target = rel->reltarget;
    ListCell   *lc1;
    int         i;
 
    i = 0;
    foreach(lc1, target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc1);
        Index       sgref = get_pathtarget_sortgroupref(target, i);
        ListCell   *lc2;
 
        /* Ignore non-sort expressions */
        if (sgref == 0 ||
            get_sortgroupref_clause_noerr(sgref,
                                          root->parse->sortClause) == NULL)
        {
            i++;
            continue;
        }
 
        /* We ignore binary-compatible relabeling on both ends */
        while (expr && IsA(expr, RelabelType))
            expr = ((RelabelType *) expr)->arg;
 
        /*
         * Locate an EquivalenceClass member matching this expr, if any.
         * Ignore child members.
         */
        foreach(lc2, ec->ec_members)
        {
            EquivalenceMember *em = (EquivalenceMember *) lfirst(lc2);
            Expr       *em_expr;
 
            /* Don't match constants */
            if (em->em_is_const)
                continue;
 
            /* Child members should not exist in ec_members */
            Assert(!em->em_is_child);
 
            /* Match if same expression (after stripping relabel) */
            em_expr = em->em_expr;
            while (em_expr && IsA(em_expr, RelabelType))
                em_expr = ((RelabelType *) em_expr)->arg;
 
            if (!equal(em_expr, expr))
                continue;
 
            /* Check that expression (including relabels!) is shippable */
            if (is_foreign_expr(root, rel, em->em_expr))
                return em;
        }
 
        i++;
    }
 
    return NULL;
}

References Assert(), EquivalenceClass::ec_members, EquivalenceMember::em_expr, EquivalenceMember::em_is_child, EquivalenceMember::em_is_const, equal(), PathTarget::exprs, 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 ForeignScan * find_modifytable_subplan	(	PlannerInfo *	root,
		ModifyTable *	plan,
		Index	rtindex,
		int	subplan_index
	)

static

Definition at line 2388 of file postgres_fdw.c.

{
    Plan       *subplan = outerPlan(plan);
 
    /*
     * The cases we support are (1) the desired ForeignScan is the immediate
     * child of ModifyTable, or (2) it is the subplan_index'th child of an
     * Append node that is the immediate child of ModifyTable.  There is no
     * point in looking further down, as that would mean that local joins are
     * involved, so we can't do the update directly.
     *
     * There could be a Result atop the Append too, acting to compute the
     * UPDATE targetlist values.  We ignore that here; the tlist will be
     * checked by our caller.
     *
     * In principle we could examine all the children of the Append, but it's
     * currently unlikely that the core planner would generate such a plan
     * with the children out-of-order.  Moreover, such a search risks costing
     * O(N^2) time when there are a lot of children.
     */
    if (IsA(subplan, Append))
    {
        Append     *appendplan = (Append *) subplan;
 
        if (subplan_index < list_length(appendplan->appendplans))
            subplan = (Plan *) list_nth(appendplan->appendplans, subplan_index);
    }
    else if (IsA(subplan, Result) &&
             outerPlan(subplan) != NULL &&
             IsA(outerPlan(subplan), Append))
    {
        Append     *appendplan = (Append *) outerPlan(subplan);
 
        if (subplan_index < list_length(appendplan->appendplans))
            subplan = (Plan *) list_nth(appendplan->appendplans, subplan_index);
    }
 
    /* Now, have we got a ForeignScan on the desired rel? */
    if (IsA(subplan, ForeignScan))
    {
        ForeignScan *fscan = (ForeignScan *) subplan;
 
        if (bms_is_member(rtindex, fscan->fs_base_relids))
            return fscan;
    }
 
    return NULL;
}

References Append::appendplans, bms_is_member(), ForeignScan::fs_base_relids, IsA, list_length(), list_nth(), outerPlan, and plan.

Referenced by postgresPlanDirectModify().

◆ finish_foreign_modify()

static void finish_foreign_modify ( PgFdwModifyState * fmstate )

static

Definition at line 4346 of file postgres_fdw.c.

{
    Assert(fmstate != NULL);
 
    /* If we created a prepared statement, destroy it */
    deallocate_query(fmstate);
 
    /* Release remote connection */
    ReleaseConnection(fmstate->conn);
    fmstate->conn = NULL;
}

References Assert(), PgFdwModifyState::conn, deallocate_query(), and ReleaseConnection().

Referenced by postgresEndForeignInsert(), and postgresEndForeignModify().

◆ foreign_grouping_ok()

static bool foreign_grouping_ok	(	PlannerInfo *	root,
		RelOptInfo *	grouped_rel,
		Node *	havingQual
	)

static

Definition at line 6408 of file postgres_fdw.c.

{
    Query      *query = root->parse;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) grouped_rel->fdw_private;
    PathTarget *grouping_target = grouped_rel->reltarget;
    PgFdwRelationInfo *ofpinfo;
    ListCell   *lc;
    int         i;
    List       *tlist = NIL;
 
    /* We currently don't support pushing Grouping Sets. */
    if (query->groupingSets)
        return false;
 
    /* Get the fpinfo of the underlying scan relation. */
    ofpinfo = (PgFdwRelationInfo *) fpinfo->outerrel->fdw_private;
 
    /*
     * If underlying scan relation has any local conditions, those conditions
     * are required to be applied before performing aggregation.  Hence the
     * aggregate cannot be pushed down.
     */
    if (ofpinfo->local_conds)
        return false;
 
    /*
     * Examine grouping expressions, as well as other expressions we'd need to
     * compute, and check whether they are safe to push down to the foreign
     * server.  All GROUP BY expressions will be part of the grouping target
     * and thus there is no need to search for them separately.  Add grouping
     * expressions into target list which will be passed to foreign server.
     *
     * A tricky fine point is that we must not put any expression into the
     * target list that is just a foreign param (that is, something that
     * deparse.c would conclude has to be sent to the foreign server).  If we
     * do, the expression will also appear in the fdw_exprs list of the plan
     * node, and setrefs.c will get confused and decide that the fdw_exprs
     * entry is actually a reference to the fdw_scan_tlist entry, resulting in
     * a broken plan.  Somewhat oddly, it's OK if the expression contains such
     * a node, as long as it's not at top level; then no match is possible.
     */
    i = 0;
    foreach(lc, grouping_target->exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        Index       sgref = get_pathtarget_sortgroupref(grouping_target, i);
        ListCell   *l;
 
        /*
         * Check whether this expression is part of GROUP BY clause.  Note we
         * check the whole GROUP BY clause not just processed_groupClause,
         * because we will ship all of it, cf. appendGroupByClause.
         */
        if (sgref && get_sortgroupref_clause_noerr(sgref, query->groupClause))
        {
            TargetEntry *tle;
 
            /*
             * If any GROUP BY expression is not shippable, then we cannot
             * push down aggregation to the foreign server.
             */
            if (!is_foreign_expr(root, grouped_rel, expr))
                return false;
 
            /*
             * If it would be a foreign param, we can't put it into the tlist,
             * so we have to fail.
             */
            if (is_foreign_param(root, grouped_rel, expr))
                return false;
 
            /*
             * Pushable, so add to tlist.  We need to create a TLE for this
             * expression and apply the sortgroupref to it.  We cannot use
             * add_to_flat_tlist() here because that avoids making duplicate
             * entries in the tlist.  If there are duplicate entries with
             * distinct sortgrouprefs, we have to duplicate that situation in
             * the output tlist.
             */
            tle = makeTargetEntry(expr, list_length(tlist) + 1, NULL, false);
            tle->ressortgroupref = sgref;
            tlist = lappend(tlist, tle);
        }
        else
        {
            /*
             * Non-grouping expression we need to compute.  Can we ship it
             * as-is to the foreign server?
             */
            if (is_foreign_expr(root, grouped_rel, expr) &&
                !is_foreign_param(root, grouped_rel, expr))
            {
                /* Yes, so add to tlist as-is; OK to suppress duplicates */
                tlist = add_to_flat_tlist(tlist, list_make1(expr));
            }
            else
            {
                /* Not pushable as a whole; extract its Vars and aggregates */
                List       *aggvars;
 
                aggvars = pull_var_clause((Node *) expr,
                                          PVC_INCLUDE_AGGREGATES);
 
                /*
                 * If any aggregate expression is not shippable, then we
                 * cannot push down aggregation to the foreign server.  (We
                 * don't have to check is_foreign_param, since that certainly
                 * won't return true for any such expression.)
                 */
                if (!is_foreign_expr(root, grouped_rel, (Expr *) aggvars))
                    return false;
 
                /*
                 * Add aggregates, if any, into the targetlist.  Plain Vars
                 * outside an aggregate can be ignored, because they should be
                 * either same as some GROUP BY column or part of some GROUP
                 * BY expression.  In either case, they are already part of
                 * the targetlist and thus no need to add them again.  In fact
                 * including plain Vars in the tlist when they do not match a
                 * GROUP BY column would cause the foreign server to complain
                 * that the shipped query is invalid.
                 */
                foreach(l, aggvars)
                {
                    Expr       *aggref = (Expr *) lfirst(l);
 
                    if (IsA(aggref, Aggref))
                        tlist = add_to_flat_tlist(tlist, list_make1(aggref));
                }
            }
        }
 
        i++;
    }
 
    /*
     * Classify the pushable and non-pushable HAVING clauses and save them in
     * remote_conds and local_conds of the grouped rel's fpinfo.
     */
    if (havingQual)
    {
        foreach(lc, (List *) havingQual)
        {
            Expr       *expr = (Expr *) lfirst(lc);
            RestrictInfo *rinfo;
 
            /*
             * Currently, the core code doesn't wrap havingQuals in
             * RestrictInfos, so we must make our own.
             */
            Assert(!IsA(expr, RestrictInfo));
            rinfo = make_restrictinfo(root,
                                      expr,
                                      true,
                                      false,
                                      false,
                                      false,
                                      root->qual_security_level,
                                      grouped_rel->relids,
                                      NULL,
                                      NULL);
            if (is_foreign_expr(root, grouped_rel, expr))
                fpinfo->remote_conds = lappend(fpinfo->remote_conds, rinfo);
            else
                fpinfo->local_conds = lappend(fpinfo->local_conds, rinfo);
        }
    }
 
    /*
     * If there are any local conditions, pull Vars and aggregates from it and
     * check whether they are safe to pushdown or not.
     */
    if (fpinfo->local_conds)
    {
        List       *aggvars = NIL;
 
        foreach(lc, fpinfo->local_conds)
        {
            RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
 
            aggvars = list_concat(aggvars,
                                  pull_var_clause((Node *) rinfo->clause,
                                                  PVC_INCLUDE_AGGREGATES));
        }
 
        foreach(lc, aggvars)
        {
            Expr       *expr = (Expr *) lfirst(lc);
 
            /*
             * If aggregates within local conditions are not safe to push
             * down, then we cannot push down the query.  Vars are already
             * part of GROUP BY clause which are checked above, so no need to
             * access them again here.  Again, we need not check
             * is_foreign_param for a foreign aggregate.
             */
            if (IsA(expr, Aggref))
            {
                if (!is_foreign_expr(root, grouped_rel, expr))
                    return false;
 
                tlist = add_to_flat_tlist(tlist, list_make1(expr));
            }
        }
    }
 
    /* Store generated targetlist */
    fpinfo->grouped_tlist = tlist;
 
    /* Safe to pushdown */
    fpinfo->pushdown_safe = true;
 
    /*
     * Set # of retrieved rows and cached relation costs to some negative
     * value, so that we can detect when they are set to some sensible values,
     * during one (usually the first) of the calls to estimate_path_cost_size.
     */
    fpinfo->retrieved_rows = -1;
    fpinfo->rel_startup_cost = -1;
    fpinfo->rel_total_cost = -1;
 
    /*
     * Set the string describing this grouped relation to be used in EXPLAIN
     * output of corresponding ForeignScan.  Note that the decoration we add
     * to the base relation name mustn't include any digits, or it'll confuse
     * postgresExplainForeignScan.
     */
    fpinfo->relation_name = psprintf("Aggregate on (%s)",
                                     ofpinfo->relation_name);
 
    return true;
}

References add_to_flat_tlist(), Assert(), RestrictInfo::clause, get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), Query::groupClause, PgFdwRelationInfo::grouped_tlist, Query::groupingSets, i, if(), is_foreign_expr(), is_foreign_param(), IsA, lappend(), lfirst, lfirst_node, list_concat(), list_length(), list_make1, PgFdwRelationInfo::local_conds, make_restrictinfo(), makeTargetEntry(), NIL, PgFdwRelationInfo::outerrel, psprintf(), pull_var_clause(), PgFdwRelationInfo::pushdown_safe, PVC_INCLUDE_AGGREGATES, PgFdwRelationInfo::rel_startup_cost, PgFdwRelationInfo::rel_total_cost, PgFdwRelationInfo::relation_name, RelOptInfo::relids, RelOptInfo::reltarget, PgFdwRelationInfo::remote_conds, TargetEntry::ressortgroupref, PgFdwRelationInfo::retrieved_rows, and root.

Referenced by add_foreign_grouping_paths().

◆ foreign_join_ok()

static bool foreign_join_ok	(	PlannerInfo *	root,
		RelOptInfo *	joinrel,
		JoinType	jointype,
		RelOptInfo *	outerrel,
		RelOptInfo *	innerrel,
		JoinPathExtraData *	extra
	)

static

Definition at line 5699 of file postgres_fdw.c.

{
    PgFdwRelationInfo *fpinfo;
    PgFdwRelationInfo *fpinfo_o;
    PgFdwRelationInfo *fpinfo_i;
    ListCell   *lc;
    List       *joinclauses;
 
    /*
     * We support pushing down INNER, LEFT, RIGHT, FULL OUTER and SEMI joins.
     * Constructing queries representing ANTI joins is hard, hence not
     * considered right now.
     */
    if (jointype != JOIN_INNER && jointype != JOIN_LEFT &&
        jointype != JOIN_RIGHT && jointype != JOIN_FULL &&
        jointype != JOIN_SEMI)
        return false;
 
    /*
     * We can't push down semi-join if its reltarget is not safe
     */
    if ((jointype == JOIN_SEMI) && !semijoin_target_ok(root, joinrel, outerrel, innerrel))
        return false;
 
    /*
     * If either of the joining relations is marked as unsafe to pushdown, the
     * join can not be pushed down.
     */
    fpinfo = (PgFdwRelationInfo *) joinrel->fdw_private;
    fpinfo_o = (PgFdwRelationInfo *) outerrel->fdw_private;
    fpinfo_i = (PgFdwRelationInfo *) innerrel->fdw_private;
    if (!fpinfo_o || !fpinfo_o->pushdown_safe ||
        !fpinfo_i || !fpinfo_i->pushdown_safe)
        return false;
 
    /*
     * If joining relations have local conditions, those conditions are
     * required to be applied before joining the relations. Hence the join can
     * not be pushed down.
     */
    if (fpinfo_o->local_conds || fpinfo_i->local_conds)
        return false;
 
    /*
     * Merge FDW options.  We might be tempted to do this after we have deemed
     * the foreign join to be OK.  But we must do this beforehand so that we
     * know which quals can be evaluated on the foreign server, which might
     * depend on shippable_extensions.
     */
    fpinfo->server = fpinfo_o->server;
    merge_fdw_options(fpinfo, fpinfo_o, fpinfo_i);
 
    /*
     * Separate restrict list into join quals and pushed-down (other) quals.
     *
     * Join quals belonging to an outer join must all be shippable, else we
     * cannot execute the join remotely.  Add such quals to 'joinclauses'.
     *
     * Add other quals to fpinfo->remote_conds if they are shippable, else to
     * fpinfo->local_conds.  In an inner join it's okay to execute conditions
     * either locally or remotely; the same is true for pushed-down conditions
     * at an outer join.
     *
     * Note we might return failure after having already scribbled on
     * fpinfo->remote_conds and fpinfo->local_conds.  That's okay because we
     * won't consult those lists again if we deem the join unshippable.
     */
    joinclauses = NIL;
    foreach(lc, extra->restrictlist)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
        bool        is_remote_clause = is_foreign_expr(root, joinrel,
                                                       rinfo->clause);
 
        if (IS_OUTER_JOIN(jointype) &&
            !RINFO_IS_PUSHED_DOWN(rinfo, joinrel->relids))
        {
            if (!is_remote_clause)
                return false;
            joinclauses = lappend(joinclauses, rinfo);
        }
        else
        {
            if (is_remote_clause)
                fpinfo->remote_conds = lappend(fpinfo->remote_conds, rinfo);
            else
                fpinfo->local_conds = lappend(fpinfo->local_conds, rinfo);
        }
    }
 
    /*
     * deparseExplicitTargetList() isn't smart enough to handle anything other
     * than a Var.  In particular, if there's some PlaceHolderVar that would
     * need to be evaluated within this join tree (because there's an upper
     * reference to a quantity that may go to NULL as a result of an outer
     * join), then we can't try to push the join down because we'll fail when
     * we get to deparseExplicitTargetList().  However, a PlaceHolderVar that
     * needs to be evaluated *at the top* of this join tree is OK, because we
     * can do that locally after fetching the results from the remote side.
     */
    foreach(lc, root->placeholder_list)
    {
        PlaceHolderInfo *phinfo = lfirst(lc);
        Relids      relids;
 
        /* PlaceHolderInfo refers to parent relids, not child relids. */
        relids = IS_OTHER_REL(joinrel) ?
            joinrel->top_parent_relids : joinrel->relids;
 
        if (bms_is_subset(phinfo->ph_eval_at, relids) &&
            bms_nonempty_difference(relids, phinfo->ph_eval_at))
            return false;
    }
 
    /* Save the join clauses, for later use. */
    fpinfo->joinclauses = joinclauses;
 
    fpinfo->outerrel = outerrel;
    fpinfo->innerrel = innerrel;
    fpinfo->jointype = jointype;
 
    /*
     * By default, both the input relations are not required to be deparsed as
     * subqueries, but there might be some relations covered by the input
     * relations that are required to be deparsed as subqueries, so save the
     * relids of those relations for later use by the deparser.
     */
    fpinfo->make_outerrel_subquery = false;
    fpinfo->make_innerrel_subquery = false;
    Assert(bms_is_subset(fpinfo_o->lower_subquery_rels, outerrel->relids));
    Assert(bms_is_subset(fpinfo_i->lower_subquery_rels, innerrel->relids));
    fpinfo->lower_subquery_rels = bms_union(fpinfo_o->lower_subquery_rels,
                                            fpinfo_i->lower_subquery_rels);
    fpinfo->hidden_subquery_rels = bms_union(fpinfo_o->hidden_subquery_rels,
                                             fpinfo_i->hidden_subquery_rels);
 
    /*
     * Pull the other remote conditions from the joining relations into join
     * clauses or other remote clauses (remote_conds) of this relation
     * wherever possible. This avoids building subqueries at every join step.
     *
     * For an inner join, clauses from both the relations are added to the
     * other remote clauses. For LEFT and RIGHT OUTER join, the clauses from
     * the outer side are added to remote_conds since those can be evaluated
     * after the join is evaluated. The clauses from inner side are added to
     * the joinclauses, since they need to be evaluated while constructing the
     * join.
     *
     * For SEMI-JOIN clauses from inner relation can not be added to
     * remote_conds, but should be treated as join clauses (as they are
     * deparsed to EXISTS subquery, where inner relation can be referred). A
     * list of relation ids, which can't be referred to from higher levels, is
     * preserved as a hidden_subquery_rels list.
     *
     * For a FULL OUTER JOIN, the other clauses from either relation can not
     * be added to the joinclauses or remote_conds, since each relation acts
     * as an outer relation for the other.
     *
     * The joining sides can not have local conditions, thus no need to test
     * shippability of the clauses being pulled up.
     */
    switch (jointype)
    {
        case JOIN_INNER:
            fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
                                               fpinfo_i->remote_conds);
            fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
                                               fpinfo_o->remote_conds);
            break;
 
        case JOIN_LEFT:
 
            /*
             * When semi-join is involved in the inner or outer part of the
             * left join, it's deparsed as a subquery, and we can't refer to
             * its vars on the upper level.
             */
            if (bms_is_empty(fpinfo_i->hidden_subquery_rels))
                fpinfo->joinclauses = list_concat(fpinfo->joinclauses,
                                                  fpinfo_i->remote_conds);
            if (bms_is_empty(fpinfo_o->hidden_subquery_rels))
                fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
                                                   fpinfo_o->remote_conds);
            break;
 
        case JOIN_RIGHT:
 
            /*
             * When semi-join is involved in the inner or outer part of the
             * right join, it's deparsed as a subquery, and we can't refer to
             * its vars on the upper level.
             */
            if (bms_is_empty(fpinfo_o->hidden_subquery_rels))
                fpinfo->joinclauses = list_concat(fpinfo->joinclauses,
                                                  fpinfo_o->remote_conds);
            if (bms_is_empty(fpinfo_i->hidden_subquery_rels))
                fpinfo->remote_conds = list_concat(fpinfo->remote_conds,
                                                   fpinfo_i->remote_conds);
            break;
 
        case JOIN_SEMI:
            fpinfo->joinclauses = list_concat(fpinfo->joinclauses,
                                              fpinfo_i->remote_conds);
            fpinfo->joinclauses = list_concat(fpinfo->joinclauses,
                                              fpinfo->remote_conds);
            fpinfo->remote_conds = list_copy(fpinfo_o->remote_conds);
            fpinfo->hidden_subquery_rels = bms_union(fpinfo->hidden_subquery_rels,
                                                     innerrel->relids);
            break;
 
        case JOIN_FULL:
 
            /*
             * In this case, if any of the input relations has conditions, we
             * need to deparse that relation as a subquery so that the
             * conditions can be evaluated before the join.  Remember it in
             * the fpinfo of this relation so that the deparser can take
             * appropriate action.  Also, save the relids of base relations
             * covered by that relation for later use by the deparser.
             */
            if (fpinfo_o->remote_conds)
            {
                fpinfo->make_outerrel_subquery = true;
                fpinfo->lower_subquery_rels =
                    bms_add_members(fpinfo->lower_subquery_rels,
                                    outerrel->relids);
            }
            if (fpinfo_i->remote_conds)
            {
                fpinfo->make_innerrel_subquery = true;
                fpinfo->lower_subquery_rels =
                    bms_add_members(fpinfo->lower_subquery_rels,
                                    innerrel->relids);
            }
            break;
 
        default:
            /* Should not happen, we have just checked this above */
            elog(ERROR, "unsupported join type %d", jointype);
    }
 
    /*
     * For an inner join, all restrictions can be treated alike. Treating the
     * pushed down conditions as join conditions allows a top level full outer
     * join to be deparsed without requiring subqueries.
     */
    if (jointype == JOIN_INNER)
    {
        Assert(!fpinfo->joinclauses);
        fpinfo->joinclauses = fpinfo->remote_conds;
        fpinfo->remote_conds = NIL;
    }
    else if (jointype == JOIN_LEFT || jointype == JOIN_RIGHT || jointype == JOIN_FULL)
    {
        /*
         * Conditions, generated from semi-joins, should be evaluated before
         * LEFT/RIGHT/FULL join.
         */
        if (!bms_is_empty(fpinfo_o->hidden_subquery_rels))
        {
            fpinfo->make_outerrel_subquery = true;
            fpinfo->lower_subquery_rels = bms_add_members(fpinfo->lower_subquery_rels, outerrel->relids);
        }
 
        if (!bms_is_empty(fpinfo_i->hidden_subquery_rels))
        {
            fpinfo->make_innerrel_subquery = true;
            fpinfo->lower_subquery_rels = bms_add_members(fpinfo->lower_subquery_rels, innerrel->relids);
        }
    }
 
    /* Mark that this join can be pushed down safely */
    fpinfo->pushdown_safe = true;
 
    /* Get user mapping */
    if (fpinfo->use_remote_estimate)
    {
        if (fpinfo_o->use_remote_estimate)
            fpinfo->user = fpinfo_o->user;
        else
            fpinfo->user = fpinfo_i->user;
    }
    else
        fpinfo->user = NULL;
 
    /*
     * Set # of retrieved rows and cached relation costs to some negative
     * value, so that we can detect when they are set to some sensible values,
     * during one (usually the first) of the calls to estimate_path_cost_size.
     */
    fpinfo->retrieved_rows = -1;
    fpinfo->rel_startup_cost = -1;
    fpinfo->rel_total_cost = -1;
 
    /*
     * Set the string describing this join relation to be used in EXPLAIN
     * output of corresponding ForeignScan.  Note that the decoration we add
     * to the base relation names mustn't include any digits, or it'll confuse
     * postgresExplainForeignScan.
     */
    fpinfo->relation_name = psprintf("(%s) %s JOIN (%s)",
                                     fpinfo_o->relation_name,
                                     get_jointype_name(fpinfo->jointype),
                                     fpinfo_i->relation_name);
 
    /*
     * Set the relation index.  This is defined as the position of this
     * joinrel in the join_rel_list list plus the length of the rtable list.
     * Note that since this joinrel is at the end of the join_rel_list list
     * when we are called, we can get the position by list_length.
     */
    Assert(fpinfo->relation_index == 0);    /* shouldn't be set yet */
    fpinfo->relation_index =
        list_length(root->parse->rtable) + list_length(root->join_rel_list);
 
    return true;
}

References Assert(), bms_add_members(), bms_is_empty, bms_is_subset(), bms_nonempty_difference(), bms_union(), RestrictInfo::clause, elog, ERROR, get_jointype_name(), PgFdwRelationInfo::hidden_subquery_rels, if(), PgFdwRelationInfo::innerrel, is_foreign_expr(), IS_OTHER_REL, IS_OUTER_JOIN, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, JOIN_SEMI, PgFdwRelationInfo::joinclauses, PgFdwRelationInfo::jointype, lappend(), lfirst, lfirst_node, list_concat(), list_copy(), list_length(), PgFdwRelationInfo::local_conds, PgFdwRelationInfo::lower_subquery_rels, PgFdwRelationInfo::make_innerrel_subquery, PgFdwRelationInfo::make_outerrel_subquery, merge_fdw_options(), NIL, PgFdwRelationInfo::outerrel, PlaceHolderInfo::ph_eval_at, psprintf(), PgFdwRelationInfo::pushdown_safe, PgFdwRelationInfo::rel_startup_cost, PgFdwRelationInfo::rel_total_cost, PgFdwRelationInfo::relation_index, PgFdwRelationInfo::relation_name, RelOptInfo::relids, PgFdwRelationInfo::remote_conds, JoinPathExtraData::restrictlist, PgFdwRelationInfo::retrieved_rows, RINFO_IS_PUSHED_DOWN, root, semijoin_target_ok(), PgFdwRelationInfo::server, RelOptInfo::top_parent_relids, PgFdwRelationInfo::use_remote_estimate, and PgFdwRelationInfo::user.

Referenced by postgresGetForeignJoinPaths().

◆ get_batch_size_option()

static int get_batch_size_option ( Relation rel )

static

Definition at line 7853 of file postgres_fdw.c.

{
    Oid         foreigntableid = RelationGetRelid(rel);
    ForeignTable *table;
    ForeignServer *server;
    List       *options;
    ListCell   *lc;
 
    /* we use 1 by default, which means "no batching" */
    int         batch_size = 1;
 
    /*
     * Load options for table and server. We append server options after table
     * options, because table options take precedence.
     */
    table = GetForeignTable(foreigntableid);
    server = GetForeignServer(table->serverid);
 
    options = NIL;
    options = list_concat(options, table->options);
    options = list_concat(options, server->options);
 
    /* See if either table or server specifies batch_size. */
    foreach(lc, options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "batch_size") == 0)
        {
            (void) parse_int(defGetString(def), &batch_size, 0, NULL);
            break;
        }
    }
 
    return batch_size;
}

References defGetString(), DefElem::defname, GetForeignServer(), GetForeignTable(), lfirst, list_concat(), NIL, options, ForeignServer::options, parse_int(), RelationGetRelid, and table.

Referenced by create_foreign_modify(), and postgresGetForeignModifyBatchSize().

◆ get_remote_estimate()

static void get_remote_estimate	(	const char *	sql,
		PGconn *	conn,
		double *	rows,
		int *	width,
		Cost *	startup_cost,
		Cost *	total_cost
	)

static

Definition at line 3603 of file postgres_fdw.c.

{
    PGresult   *res;
    char       *line;
    char       *p;
    int         n;
 
    /*
     * Execute EXPLAIN remotely.
     */
    res = pgfdw_exec_query(conn, sql, NULL);
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
        pgfdw_report_error(res, conn, sql);
 
    /*
     * Extract cost numbers for topmost plan node.  Note we search for a left
     * paren from the end of the line to avoid being confused by other uses of
     * parentheses.
     */
    line = PQgetvalue(res, 0, 0);
    p = strrchr(line, '(');
    if (p == NULL)
        elog(ERROR, "could not interpret EXPLAIN output: \"%s\"", line);
    n = sscanf(p, "(cost=%lf..%lf rows=%lf width=%d)",
               startup_cost, total_cost, rows, width);
    if (n != 4)
        elog(ERROR, "could not interpret EXPLAIN output: \"%s\"", line);
    PQclear(res);
}

References conn, elog, ERROR, pgfdw_exec_query(), pgfdw_report_error(), PGRES_TUPLES_OK, PQclear, PQgetvalue, and PQresultStatus.

Referenced by estimate_path_cost_size().

◆ get_returning_data()

static TupleTableSlot * get_returning_data ( ForeignScanState * node )

static

Definition at line 4573 of file postgres_fdw.c.

{
    PgFdwDirectModifyState *dmstate = (PgFdwDirectModifyState *) node->fdw_state;
    EState     *estate = node->ss.ps.state;
    ResultRelInfo *resultRelInfo = node->resultRelInfo;
    TupleTableSlot *slot = node->ss.ss_ScanTupleSlot;
    TupleTableSlot *resultSlot;
 
    Assert(resultRelInfo->ri_projectReturning);
 
    /* If we didn't get any tuples, must be end of data. */
    if (dmstate->next_tuple >= dmstate->num_tuples)
        return ExecClearTuple(slot);
 
    /* Increment the command es_processed count if necessary. */
    if (dmstate->set_processed)
        estate->es_processed += 1;
 
    /*
     * Store a RETURNING tuple.  If has_returning is false, just emit a dummy
     * tuple.  (has_returning is false when the local query is of the form
     * "UPDATE/DELETE .. RETURNING 1" for example.)
     */
    if (!dmstate->has_returning)
    {
        ExecStoreAllNullTuple(slot);
        resultSlot = slot;
    }
    else
    {
        HeapTuple   newtup;
 
        newtup = make_tuple_from_result_row(dmstate->result,
                                            dmstate->next_tuple,
                                            dmstate->rel,
                                            dmstate->attinmeta,
                                            dmstate->retrieved_attrs,
                                            node,
                                            dmstate->temp_cxt);
        ExecStoreHeapTuple(newtup, slot, false);
        /* Get the updated/deleted tuple. */
        if (dmstate->rel)
            resultSlot = slot;
        else
            resultSlot = apply_returning_filter(dmstate, resultRelInfo, slot, estate);
    }
    dmstate->next_tuple++;
 
    /* Make slot available for evaluation of the local query RETURNING list. */
    resultRelInfo->ri_projectReturning->pi_exprContext->ecxt_scantuple =
        resultSlot;
 
    return slot;
}

Referenced by postgresIterateDirectModify().

◆ get_tupdesc_for_join_scan_tuples()

static TupleDesc get_tupdesc_for_join_scan_tuples ( ForeignScanState * node )

static

Definition at line 1447 of file postgres_fdw.c.

{
    ForeignScan *fsplan = (ForeignScan *) node->ss.ps.plan;
    EState     *estate = node->ss.ps.state;
    TupleDesc   tupdesc;
 
    /*
     * The core code has already set up a scan tuple slot based on
     * fsplan->fdw_scan_tlist, and this slot's tupdesc is mostly good enough,
     * but there's one case where it isn't.  If we have any whole-row row
     * identifier Vars, they may have vartype RECORD, and we need to replace
     * that with the associated table's actual composite type.  This ensures
     * that when we read those ROW() expression values from the remote server,
     * we can convert them to a composite type the local server knows.
     */
    tupdesc = CreateTupleDescCopy(node->ss.ss_ScanTupleSlot->tts_tupleDescriptor);
    for (int i = 0; i < tupdesc->natts; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupdesc, i);
        Var        *var;
        RangeTblEntry *rte;
        Oid         reltype;
 
        /* Nothing to do if it's not a generic RECORD attribute */
        if (att->atttypid != RECORDOID || att->atttypmod >= 0)
            continue;
 
        /*
         * If we can't identify the referenced table, do nothing.  This'll
         * likely lead to failure later, but perhaps we can muddle through.
         */
        var = (Var *) list_nth_node(TargetEntry, fsplan->fdw_scan_tlist,
                                    i)->expr;
        if (!IsA(var, Var) || var->varattno != 0)
            continue;
        rte = list_nth(estate->es_range_table, var->varno - 1);
        if (rte->rtekind != RTE_RELATION)
            continue;
        reltype = get_rel_type_id(rte->relid);
        if (!OidIsValid(reltype))
            continue;
        att->atttypid = reltype;
        /* shouldn't need to change anything else */
    }
    return tupdesc;
}

References CreateTupleDescCopy(), ForeignScan::fdw_scan_tlist, get_rel_type_id(), i, IsA, list_nth(), list_nth_node, OidIsValid, PlanState::plan, ScanState::ps, RTE_RELATION, RangeTblEntry::rtekind, 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 List * get_useful_ecs_for_relation	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

static

Definition at line 813 of file postgres_fdw.c.

{
    List       *useful_eclass_list = NIL;
    ListCell   *lc;
    Relids      relids;
 
    /*
     * First, consider whether any active EC is potentially useful for a merge
     * join against this relation.
     */
    if (rel->has_eclass_joins)
    {
        foreach(lc, root->eq_classes)
        {
            EquivalenceClass *cur_ec = (EquivalenceClass *) lfirst(lc);
 
            if (eclass_useful_for_merging(root, cur_ec, rel))
                useful_eclass_list = lappend(useful_eclass_list, cur_ec);
        }
    }
 
    /*
     * Next, consider whether there are any non-EC derivable join clauses that
     * are merge-joinable.  If the joininfo list is empty, we can exit
     * quickly.
     */
    if (rel->joininfo == NIL)
        return useful_eclass_list;
 
    /* If this is a child rel, we must use the topmost parent rel to search. */
    if (IS_OTHER_REL(rel))
    {
        Assert(!bms_is_empty(rel->top_parent_relids));
        relids = rel->top_parent_relids;
    }
    else
        relids = rel->relids;
 
    /* Check each join clause in turn. */
    foreach(lc, rel->joininfo)
    {
        RestrictInfo *restrictinfo = (RestrictInfo *) lfirst(lc);
 
        /* Consider only mergejoinable clauses */
        if (restrictinfo->mergeopfamilies == NIL)
            continue;
 
        /* Make sure we've got canonical ECs. */
        update_mergeclause_eclasses(root, restrictinfo);
 
        /*
         * restrictinfo->mergeopfamilies != NIL is sufficient to guarantee
         * that left_ec and right_ec will be initialized, per comments in
         * distribute_qual_to_rels.
         *
         * We want to identify which side of this merge-joinable clause
         * contains columns from the relation produced by this RelOptInfo. We
         * test for overlap, not containment, because there could be extra
         * relations on either side.  For example, suppose we've got something
         * like ((A JOIN B ON A.x = B.x) JOIN C ON A.y = C.y) LEFT JOIN D ON
         * A.y = D.y.  The input rel might be the joinrel between A and B, and
         * we'll consider the join clause A.y = D.y. relids contains a
         * relation not involved in the join class (B) and the equivalence
         * class for the left-hand side of the clause contains a relation not
         * involved in the input rel (C).  Despite the fact that we have only
         * overlap and not containment in either direction, A.y is potentially
         * useful as a sort column.
         *
         * Note that it's even possible that relids overlaps neither side of
         * the join clause.  For example, consider A LEFT JOIN B ON A.x = B.x
         * AND A.x = 1.  The clause A.x = 1 will appear in B's joininfo list,
         * but overlaps neither side of B.  In that case, we just skip this
         * join clause, since it doesn't suggest a useful sort order for this
         * relation.
         */
        if (bms_overlap(relids, restrictinfo->right_ec->ec_relids))
            useful_eclass_list = list_append_unique_ptr(useful_eclass_list,
                                                        restrictinfo->right_ec);
        else if (bms_overlap(relids, restrictinfo->left_ec->ec_relids))
            useful_eclass_list = list_append_unique_ptr(useful_eclass_list,
                                                        restrictinfo->left_ec);
    }
 
    return useful_eclass_list;
}

References Assert(), bms_is_empty, bms_overlap(), eclass_useful_for_merging(), 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 List * get_useful_pathkeys_for_relation	(	PlannerInfo *	root,
		RelOptInfo *	rel
	)

static

Definition at line 909 of file postgres_fdw.c.

{
    List       *useful_pathkeys_list = NIL;
    List       *useful_eclass_list;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) rel->fdw_private;
    EquivalenceClass *query_ec = NULL;
    ListCell   *lc;
 
    /*
     * Pushing the query_pathkeys to the remote server is always worth
     * considering, because it might let us avoid a local sort.
     */
    fpinfo->qp_is_pushdown_safe = false;
    if (root->query_pathkeys)
    {
        bool        query_pathkeys_ok = true;
 
        foreach(lc, root->query_pathkeys)
        {
            PathKey    *pathkey = (PathKey *) lfirst(lc);
 
            /*
             * The planner and executor don't have any clever strategy for
             * taking data sorted by a prefix of the query's pathkeys and
             * getting it to be sorted by all of those pathkeys. We'll just
             * end up resorting the entire data set.  So, unless we can push
             * down all of the query pathkeys, forget it.
             */
            if (!is_foreign_pathkey(root, rel, pathkey))
            {
                query_pathkeys_ok = false;
                break;
            }
        }
 
        if (query_pathkeys_ok)
        {
            useful_pathkeys_list = list_make1(list_copy(root->query_pathkeys));
            fpinfo->qp_is_pushdown_safe = true;
        }
    }
 
    /*
     * Even if we're not using remote estimates, having the remote side do the
     * sort generally won't be any worse than doing it locally, and it might
     * be much better if the remote side can generate data in the right order
     * without needing a sort at all.  However, what we're going to do next is
     * try to generate pathkeys that seem promising for possible merge joins,
     * and that's more speculative.  A wrong choice might hurt quite a bit, so
     * bail out if we can't use remote estimates.
     */
    if (!fpinfo->use_remote_estimate)
        return useful_pathkeys_list;
 
    /* Get the list of interesting EquivalenceClasses. */
    useful_eclass_list = get_useful_ecs_for_relation(root, rel);
 
    /* Extract unique EC for query, if any, so we don't consider it again. */
    if (list_length(root->query_pathkeys) == 1)
    {
        PathKey    *query_pathkey = linitial(root->query_pathkeys);
 
        query_ec = query_pathkey->pk_eclass;
    }
 
    /*
     * As a heuristic, the only pathkeys we consider here are those of length
     * one.  It's surely possible to consider more, but since each one we
     * choose to consider will generate a round-trip to the remote side, we
     * need to be a bit cautious here.  It would sure be nice to have a local
     * cache of information about remote index definitions...
     */
    foreach(lc, useful_eclass_list)
    {
        EquivalenceClass *cur_ec = lfirst(lc);
        PathKey    *pathkey;
 
        /* If redundant with what we did above, skip it. */
        if (cur_ec == query_ec)
            continue;
 
        /* Can't push down the sort if the EC's opfamily is not shippable. */
        if (!is_shippable(linitial_oid(cur_ec->ec_opfamilies),
                          OperatorFamilyRelationId, fpinfo))
            continue;
 
        /* If no pushable expression for this rel, skip it. */
        if (find_em_for_rel(root, cur_ec, rel) == NULL)
            continue;
 
        /* Looks like we can generate a pathkey, so let's do it. */
        pathkey = make_canonical_pathkey(root, cur_ec,
                                         linitial_oid(cur_ec->ec_opfamilies),
                                         COMPARE_LT,
                                         false);
        useful_pathkeys_list = lappend(useful_pathkeys_list,
                                       list_make1(pathkey));
    }
 
    return useful_pathkeys_list;
}

References COMPARE_LT, EquivalenceClass::ec_opfamilies, find_em_for_rel(), get_useful_ecs_for_relation(), if(), is_foreign_pathkey(), is_shippable(), lappend(), lfirst, linitial, linitial_oid, list_copy(), list_length(), list_make1, make_canonical_pathkey(), NIL, PgFdwRelationInfo::qp_is_pushdown_safe, root, and PgFdwRelationInfo::use_remote_estimate.

Referenced by add_paths_with_pathkeys_for_rel().

◆ init_returning_filter()

static void init_returning_filter	(	PgFdwDirectModifyState *	dmstate,
		List *	fdw_scan_tlist,
		Index	rtindex
	)

static

Definition at line 4632 of file postgres_fdw.c.

{
    TupleDesc   resultTupType = RelationGetDescr(dmstate->resultRel);
    ListCell   *lc;
    int         i;
 
    /*
     * Calculate the mapping between the fdw_scan_tlist's entries and the
     * result tuple's attributes.
     *
     * The "map" is an array of indexes of the result tuple's attributes in
     * fdw_scan_tlist, i.e., one entry for every attribute of the result
     * tuple.  We store zero for any attributes that don't have the
     * corresponding entries in that list, marking that a NULL is needed in
     * the result tuple.
     *
     * Also get the indexes of the entries for ctid and oid if any.
     */
    dmstate->attnoMap = (AttrNumber *)
        palloc0(resultTupType->natts * sizeof(AttrNumber));
 
    dmstate->ctidAttno = dmstate->oidAttno = 0;
 
    i = 1;
    dmstate->hasSystemCols = false;
    foreach(lc, fdw_scan_tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(lc);
        Var        *var = (Var *) tle->expr;
 
        Assert(IsA(var, Var));
 
        /*
         * If the Var is a column of the target relation to be retrieved from
         * the foreign server, get the index of the entry.
         */
        if (var->varno == rtindex &&
            list_member_int(dmstate->retrieved_attrs, i))
        {
            int         attrno = var->varattno;
 
            if (attrno < 0)
            {
                /*
                 * We don't retrieve system columns other than ctid and oid.
                 */
                if (attrno == SelfItemPointerAttributeNumber)
                    dmstate->ctidAttno = i;
                else
                    Assert(false);
                dmstate->hasSystemCols = true;
            }
            else
            {
                /*
                 * We don't retrieve whole-row references to the target
                 * relation either.
                 */
                Assert(attrno > 0);
 
                dmstate->attnoMap[attrno - 1] = i;
            }
        }
        i++;
    }
}

References Assert(), PgFdwDirectModifyState::attnoMap, PgFdwDirectModifyState::ctidAttno, TargetEntry::expr, PgFdwDirectModifyState::hasSystemCols, i, IsA, lfirst, list_member_int(), TupleDescData::natts, PgFdwDirectModifyState::oidAttno, palloc0(), RelationGetDescr, PgFdwDirectModifyState::resultRel, PgFdwDirectModifyState::retrieved_attrs, SelfItemPointerAttributeNumber, Var::varattno, and Var::varno.

Referenced by postgresBeginDirectModify().

◆ make_tuple_from_result_row()

static HeapTuple make_tuple_from_result_row	(	PGresult *	res,
		int	row,
		Relation	rel,
		AttInMetadata *	attinmeta,
		List *	retrieved_attrs,
		ForeignScanState *	fsstate,
		MemoryContext	temp_context
	)

static

Definition at line 7491 of file postgres_fdw.c.

{
    HeapTuple   tuple;
    TupleDesc   tupdesc;
    Datum      *values;
    bool       *nulls;
    ItemPointer ctid = NULL;
    ConversionLocation errpos;
    ErrorContextCallback errcallback;
    MemoryContext oldcontext;
    ListCell   *lc;
    int         j;
 
    Assert(row < PQntuples(res));
 
    /*
     * Do the following work in a temp context that we reset after each tuple.
     * This cleans up not only the data we have direct access to, but any
     * cruft the I/O functions might leak.
     */
    oldcontext = MemoryContextSwitchTo(temp_context);
 
    /*
     * Get the tuple descriptor for the row.  Use the rel's tupdesc if rel is
     * provided, otherwise look to the scan node's ScanTupleSlot.
     */
    if (rel)
        tupdesc = RelationGetDescr(rel);
    else
    {
        Assert(fsstate);
        tupdesc = fsstate->ss.ss_ScanTupleSlot->tts_tupleDescriptor;
    }
 
    values = (Datum *) palloc0(tupdesc->natts * sizeof(Datum));
    nulls = (bool *) palloc(tupdesc->natts * sizeof(bool));
    /* Initialize to nulls for any columns not present in result */
    memset(nulls, true, tupdesc->natts * sizeof(bool));
 
    /*
     * Set up and install callback to report where conversion error occurs.
     */
    errpos.cur_attno = 0;
    errpos.rel = rel;
    errpos.fsstate = fsstate;
    errcallback.callback = conversion_error_callback;
    errcallback.arg = &errpos;
    errcallback.previous = error_context_stack;
    error_context_stack = &errcallback;
 
    /*
     * i indexes columns in the relation, j indexes columns in the PGresult.
     */
    j = 0;
    foreach(lc, retrieved_attrs)
    {
        int         i = lfirst_int(lc);
        char       *valstr;
 
        /* fetch next column's textual value */
        if (PQgetisnull(res, row, j))
            valstr = NULL;
        else
            valstr = PQgetvalue(res, row, j);
 
        /*
         * convert value to internal representation
         *
         * Note: we ignore system columns other than ctid and oid in result
         */
        errpos.cur_attno = i;
        if (i > 0)
        {
            /* ordinary column */
            Assert(i <= tupdesc->natts);
            nulls[i - 1] = (valstr == NULL);
            /* Apply the input function even to nulls, to support domains */
            values[i - 1] = InputFunctionCall(&attinmeta->attinfuncs[i - 1],
                                              valstr,
                                              attinmeta->attioparams[i - 1],
                                              attinmeta->atttypmods[i - 1]);
        }
        else if (i == SelfItemPointerAttributeNumber)
        {
            /* ctid */
            if (valstr != NULL)
            {
                Datum       datum;
 
                datum = DirectFunctionCall1(tidin, CStringGetDatum(valstr));
                ctid = (ItemPointer) DatumGetPointer(datum);
            }
        }
        errpos.cur_attno = 0;
 
        j++;
    }
 
    /* Uninstall error context callback. */
    error_context_stack = errcallback.previous;
 
    /*
     * Check we got the expected number of columns.  Note: j == 0 and
     * PQnfields == 1 is expected, since deparse emits a NULL if no columns.
     */
    if (j > 0 && j != PQnfields(res))
        elog(ERROR, "remote query result does not match the foreign table");
 
    /*
     * Build the result tuple in caller's memory context.
     */
    MemoryContextSwitchTo(oldcontext);
 
    tuple = heap_form_tuple(tupdesc, values, nulls);
 
    /*
     * If we have a CTID to return, install it in both t_self and t_ctid.
     * t_self is the normal place, but if the tuple is converted to a
     * composite Datum, t_self will be lost; setting t_ctid allows CTID to be
     * preserved during EvalPlanQual re-evaluations (see ROW_MARK_COPY code).
     */
    if (ctid)
        tuple->t_self = tuple->t_data->t_ctid = *ctid;
 
    /*
     * Stomp on the xmin, xmax, and cmin fields from the tuple created by
     * heap_form_tuple.  heap_form_tuple actually creates the tuple with
     * DatumTupleFields, not HeapTupleFields, but the executor expects
     * HeapTupleFields and will happily extract system columns on that
     * assumption.  If we don't do this then, for example, the tuple length
     * ends up in the xmin field, which isn't what we want.
     */
    HeapTupleHeaderSetXmax(tuple->t_data, InvalidTransactionId);
    HeapTupleHeaderSetXmin(tuple->t_data, InvalidTransactionId);
    HeapTupleHeaderSetCmin(tuple->t_data, InvalidTransactionId);
 
    /* Clean up */
    MemoryContextReset(temp_context);
 
    return tuple;
}

References ErrorContextCallback::arg, Assert(), AttInMetadata::attinfuncs, AttInMetadata::attioparams, AttInMetadata::atttypmods, ErrorContextCallback::callback, conversion_error_callback(), CStringGetDatum(), ConversionLocation::cur_attno, DatumGetPointer(), DirectFunctionCall1, elog, ERROR, error_context_stack, ConversionLocation::fsstate, heap_form_tuple(), HeapTupleHeaderSetCmin(), HeapTupleHeaderSetXmax(), HeapTupleHeaderSetXmin(), i, InputFunctionCall(), InvalidTransactionId, j, lfirst_int, MemoryContextReset(), MemoryContextSwitchTo(), TupleDescData::natts, palloc(), palloc0(), PQgetisnull, PQgetvalue, PQnfields, PQntuples, ErrorContextCallback::previous, ConversionLocation::rel, 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 void merge_fdw_options	(	PgFdwRelationInfo *	fpinfo,
		const PgFdwRelationInfo *	fpinfo_o,
		const PgFdwRelationInfo *	fpinfo_i
	)

static

Definition at line 6202 of file postgres_fdw.c.

{
    /* We must always have fpinfo_o. */
    Assert(fpinfo_o);
 
    /* fpinfo_i may be NULL, but if present the servers must both match. */
    Assert(!fpinfo_i ||
           fpinfo_i->server->serverid == fpinfo_o->server->serverid);
 
    /*
     * Copy the server specific FDW options.  (For a join, both relations come
     * from the same server, so the server options should have the same value
     * for both relations.)
     */
    fpinfo->fdw_startup_cost = fpinfo_o->fdw_startup_cost;
    fpinfo->fdw_tuple_cost = fpinfo_o->fdw_tuple_cost;
    fpinfo->shippable_extensions = fpinfo_o->shippable_extensions;
    fpinfo->use_remote_estimate = fpinfo_o->use_remote_estimate;
    fpinfo->fetch_size = fpinfo_o->fetch_size;
    fpinfo->async_capable = fpinfo_o->async_capable;
 
    /* Merge the table level options from either side of the join. */
    if (fpinfo_i)
    {
        /*
         * We'll prefer to use remote estimates for this join if any table
         * from either side of the join is using remote estimates.  This is
         * most likely going to be preferred since they're already willing to
         * pay the price of a round trip to get the remote EXPLAIN.  In any
         * case it's not entirely clear how we might otherwise handle this
         * best.
         */
        fpinfo->use_remote_estimate = fpinfo_o->use_remote_estimate ||
            fpinfo_i->use_remote_estimate;
 
        /*
         * Set fetch size to maximum of the joining sides, since we are
         * expecting the rows returned by the join to be proportional to the
         * relation sizes.
         */
        fpinfo->fetch_size = Max(fpinfo_o->fetch_size, fpinfo_i->fetch_size);
 
        /*
         * We'll prefer to consider this join async-capable if any table from
         * either side of the join is considered async-capable.  This would be
         * reasonable because in that case the foreign server would have its
         * own resources to scan that table asynchronously, and the join could
         * also be computed asynchronously using the resources.
         */
        fpinfo->async_capable = fpinfo_o->async_capable ||
            fpinfo_i->async_capable;
    }
}

References Assert(), PgFdwRelationInfo::async_capable, PgFdwRelationInfo::fdw_startup_cost, PgFdwRelationInfo::fdw_tuple_cost, PgFdwRelationInfo::fetch_size, Max, PgFdwRelationInfo::server, ForeignServer::serverid, PgFdwRelationInfo::shippable_extensions, and PgFdwRelationInfo::use_remote_estimate.

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.

{
    FdwRoutine *routine = makeNode(FdwRoutine);
 
    /* Functions for scanning foreign tables */
    routine->GetForeignRelSize = postgresGetForeignRelSize;
    routine->GetForeignPaths = postgresGetForeignPaths;
    routine->GetForeignPlan = postgresGetForeignPlan;
    routine->BeginForeignScan = postgresBeginForeignScan;
    routine->IterateForeignScan = postgresIterateForeignScan;
    routine->ReScanForeignScan = postgresReScanForeignScan;
    routine->EndForeignScan = postgresEndForeignScan;
 
    /* Functions for updating foreign tables */
    routine->AddForeignUpdateTargets = postgresAddForeignUpdateTargets;
    routine->PlanForeignModify = postgresPlanForeignModify;
    routine->BeginForeignModify = postgresBeginForeignModify;
    routine->ExecForeignInsert = postgresExecForeignInsert;
    routine->ExecForeignBatchInsert = postgresExecForeignBatchInsert;
    routine->GetForeignModifyBatchSize = postgresGetForeignModifyBatchSize;
    routine->ExecForeignUpdate = postgresExecForeignUpdate;
    routine->ExecForeignDelete = postgresExecForeignDelete;
    routine->EndForeignModify = postgresEndForeignModify;
    routine->BeginForeignInsert = postgresBeginForeignInsert;
    routine->EndForeignInsert = postgresEndForeignInsert;
    routine->IsForeignRelUpdatable = postgresIsForeignRelUpdatable;
    routine->PlanDirectModify = postgresPlanDirectModify;
    routine->BeginDirectModify = postgresBeginDirectModify;
    routine->IterateDirectModify = postgresIterateDirectModify;
    routine->EndDirectModify = postgresEndDirectModify;
 
    /* Function for EvalPlanQual rechecks */
    routine->RecheckForeignScan = postgresRecheckForeignScan;
    /* Support functions for EXPLAIN */
    routine->ExplainForeignScan = postgresExplainForeignScan;
    routine->ExplainForeignModify = postgresExplainForeignModify;
    routine->ExplainDirectModify = postgresExplainDirectModify;
 
    /* Support function for TRUNCATE */
    routine->ExecForeignTruncate = postgresExecForeignTruncate;
 
    /* Support functions for ANALYZE */
    routine->AnalyzeForeignTable = postgresAnalyzeForeignTable;
 
    /* Support functions for IMPORT FOREIGN SCHEMA */
    routine->ImportForeignSchema = postgresImportForeignSchema;
 
    /* Support functions for join push-down */
    routine->GetForeignJoinPaths = postgresGetForeignJoinPaths;
 
    /* Support functions for upper relation push-down */
    routine->GetForeignUpperPaths = postgresGetForeignUpperPaths;
 
    /* Support functions for asynchronous execution */
    routine->IsForeignPathAsyncCapable = postgresIsForeignPathAsyncCapable;
    routine->ForeignAsyncRequest = postgresForeignAsyncRequest;
    routine->ForeignAsyncConfigureWait = postgresForeignAsyncConfigureWait;
    routine->ForeignAsyncNotify = postgresForeignAsyncNotify;
 
    PG_RETURN_POINTER(routine);
}

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 int postgresAcquireSampleRowsFunc	(	Relation	relation,
		int	elevel,
		HeapTuple *	rows,
		int	targrows,
		double *	totalrows,
		double *	totaldeadrows
	)

static

Definition at line 5008 of file postgres_fdw.c.

{
    PgFdwAnalyzeState astate;
    ForeignTable *table;
    ForeignServer *server;
    UserMapping *user;
    PGconn     *conn;
    int         server_version_num;
    PgFdwSamplingMethod method = ANALYZE_SAMPLE_AUTO;   /* auto is default */
    double      sample_frac = -1.0;
    double      reltuples = -1.0;
    unsigned int cursor_number;
    StringInfoData sql;
    PGresult   *res;
    char        fetch_sql[64];
    int         fetch_size;
    ListCell   *lc;
 
    /* Initialize workspace state */
    astate.rel = relation;
    astate.attinmeta = TupleDescGetAttInMetadata(RelationGetDescr(relation));
 
    astate.rows = rows;
    astate.targrows = targrows;
    astate.numrows = 0;
    astate.samplerows = 0;
    astate.rowstoskip = -1;     /* -1 means not set yet */
    reservoir_init_selection_state(&astate.rstate, targrows);
 
    /* Remember ANALYZE context, and create a per-tuple temp context */
    astate.anl_cxt = CurrentMemoryContext;
    astate.temp_cxt = AllocSetContextCreate(CurrentMemoryContext,
                                            "postgres_fdw temporary data",
                                            ALLOCSET_SMALL_SIZES);
 
    /*
     * Get the connection to use.  We do the remote access as the table's
     * owner, even if the ANALYZE was started by some other user.
     */
    table = GetForeignTable(RelationGetRelid(relation));
    server = GetForeignServer(table->serverid);
    user = GetUserMapping(relation->rd_rel->relowner, table->serverid);
    conn = GetConnection(user, false, NULL);
 
    /* We'll need server version, so fetch it now. */
    server_version_num = PQserverVersion(conn);
 
    /*
     * What sampling method should we use?
     */
    foreach(lc, server->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "analyze_sampling") == 0)
        {
            char       *value = defGetString(def);
 
            if (strcmp(value, "off") == 0)
                method = ANALYZE_SAMPLE_OFF;
            else if (strcmp(value, "auto") == 0)
                method = ANALYZE_SAMPLE_AUTO;
            else if (strcmp(value, "random") == 0)
                method = ANALYZE_SAMPLE_RANDOM;
            else if (strcmp(value, "system") == 0)
                method = ANALYZE_SAMPLE_SYSTEM;
            else if (strcmp(value, "bernoulli") == 0)
                method = ANALYZE_SAMPLE_BERNOULLI;
 
            break;
        }
    }
 
    foreach(lc, table->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "analyze_sampling") == 0)
        {
            char       *value = defGetString(def);
 
            if (strcmp(value, "off") == 0)
                method = ANALYZE_SAMPLE_OFF;
            else if (strcmp(value, "auto") == 0)
                method = ANALYZE_SAMPLE_AUTO;
            else if (strcmp(value, "random") == 0)
                method = ANALYZE_SAMPLE_RANDOM;
            else if (strcmp(value, "system") == 0)
                method = ANALYZE_SAMPLE_SYSTEM;
            else if (strcmp(value, "bernoulli") == 0)
                method = ANALYZE_SAMPLE_BERNOULLI;
 
            break;
        }
    }
 
    /*
     * Error-out if explicitly required one of the TABLESAMPLE methods, but
     * the server does not support it.
     */
    if ((server_version_num < 95000) &&
        (method == ANALYZE_SAMPLE_SYSTEM ||
         method == ANALYZE_SAMPLE_BERNOULLI))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("remote server does not support TABLESAMPLE feature")));
 
    /*
     * If we've decided to do remote sampling, calculate the sampling rate. We
     * need to get the number of tuples from the remote server, but skip that
     * network round-trip if not needed.
     */
    if (method != ANALYZE_SAMPLE_OFF)
    {
        bool        can_tablesample;
 
        reltuples = postgresGetAnalyzeInfoForForeignTable(relation,
                                                          &can_tablesample);
 
        /*
         * Make sure we're not choosing TABLESAMPLE when the remote relation
         * does not support that. But only do this for "auto" - if the user
         * explicitly requested BERNOULLI/SYSTEM, it's better to fail.
         */
        if (!can_tablesample && (method == ANALYZE_SAMPLE_AUTO))
            method = ANALYZE_SAMPLE_RANDOM;
 
        /*
         * Remote's reltuples could be 0 or -1 if the table has never been
         * vacuumed/analyzed.  In that case, disable sampling after all.
         */
        if ((reltuples <= 0) || (targrows >= reltuples))
            method = ANALYZE_SAMPLE_OFF;
        else
        {
            /*
             * All supported sampling methods require sampling rate, not
             * target rows directly, so we calculate that using the remote
             * reltuples value. That's imperfect, because it might be off a
             * good deal, but that's not something we can (or should) address
             * here.
             *
             * If reltuples is too low (i.e. when table grew), we'll end up
             * sampling more rows - but then we'll apply the local sampling,
             * so we get the expected sample size. This is the same outcome as
             * without remote sampling.
             *
             * If reltuples is too high (e.g. after bulk DELETE), we will end
             * up sampling too few rows.
             *
             * We can't really do much better here - we could try sampling a
             * bit more rows, but we don't know how off the reltuples value is
             * so how much is "a bit more"?
             *
             * Furthermore, the targrows value for partitions is determined
             * based on table size (relpages), which can be off in different
             * ways too. Adjusting the sampling rate here might make the issue
             * worse.
             */
            sample_frac = targrows / reltuples;
 
            /*
             * We should never get sampling rate outside the valid range
             * (between 0.0 and 1.0), because those cases should be covered by
             * the previous branch that sets ANALYZE_SAMPLE_OFF.
             */
            Assert(sample_frac >= 0.0 && sample_frac <= 1.0);
        }
    }
 
    /*
     * For "auto" method, pick the one we believe is best. For servers with
     * TABLESAMPLE support we pick BERNOULLI, for old servers we fall-back to
     * random() to at least reduce network transfer.
     */
    if (method == ANALYZE_SAMPLE_AUTO)
    {
        if (server_version_num < 95000)
            method = ANALYZE_SAMPLE_RANDOM;
        else
            method = ANALYZE_SAMPLE_BERNOULLI;
    }
 
    /*
     * Construct cursor that retrieves whole rows from remote.
     */
    cursor_number = GetCursorNumber(conn);
    initStringInfo(&sql);
    appendStringInfo(&sql, "DECLARE c%u CURSOR FOR ", cursor_number);
 
    deparseAnalyzeSql(&sql, relation, method, sample_frac, &astate.retrieved_attrs);
 
    res = pgfdw_exec_query(conn, sql.data, NULL);
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
        pgfdw_report_error(res, conn, sql.data);
    PQclear(res);
 
    /*
     * Determine the fetch size.  The default is arbitrary, but shouldn't be
     * enormous.
     */
    fetch_size = 100;
    foreach(lc, server->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "fetch_size") == 0)
        {
            (void) parse_int(defGetString(def), &fetch_size, 0, NULL);
            break;
        }
    }
    foreach(lc, table->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "fetch_size") == 0)
        {
            (void) parse_int(defGetString(def), &fetch_size, 0, NULL);
            break;
        }
    }
 
    /* Construct command to fetch rows from remote. */
    snprintf(fetch_sql, sizeof(fetch_sql), "FETCH %d FROM c%u",
             fetch_size, cursor_number);
 
    /* Retrieve and process rows a batch at a time. */
    for (;;)
    {
        int         numrows;
        int         i;
 
        /* Allow users to cancel long query */
        CHECK_FOR_INTERRUPTS();
 
        /*
         * XXX possible future improvement: if rowstoskip is large, we could
         * issue a MOVE rather than physically fetching the rows, then just
         * adjust rowstoskip and samplerows appropriately.
         */
 
        /* Fetch some rows */
        res = pgfdw_exec_query(conn, fetch_sql, NULL);
        /* On error, report the original query, not the FETCH. */
        if (PQresultStatus(res) != PGRES_TUPLES_OK)
            pgfdw_report_error(res, conn, sql.data);
 
        /* Process whatever we got. */
        numrows = PQntuples(res);
        for (i = 0; i < numrows; i++)
            analyze_row_processor(res, i, &astate);
 
        PQclear(res);
 
        /* Must be EOF if we didn't get all the rows requested. */
        if (numrows < fetch_size)
            break;
    }
 
    /* Close the cursor, just to be tidy. */
    close_cursor(conn, cursor_number, NULL);
 
    ReleaseConnection(conn);
 
    /* We assume that we have no dead tuple. */
    *totaldeadrows = 0.0;
 
    /*
     * Without sampling, we've retrieved all living tuples from foreign
     * server, so report that as totalrows.  Otherwise use the reltuples
     * estimate we got from the remote side.
     */
    if (method == ANALYZE_SAMPLE_OFF)
        *totalrows = astate.samplerows;
    else
        *totalrows = reltuples;
 
    /*
     * Emit some interesting relation info
     */
    ereport(elevel,
            (errmsg("\"%s\": table contains %.0f rows, %d rows in sample",
                    RelationGetRelationName(relation),
                    *totalrows, astate.numrows)));
 
    return astate.numrows;
}

Referenced by postgresAnalyzeForeignTable().

◆ postgresAddForeignUpdateTargets()

static void postgresAddForeignUpdateTargets	(	PlannerInfo *	root,
		Index	rtindex,
		RangeTblEntry *	target_rte,
		Relation	target_relation
	)

static

Definition at line 1748 of file postgres_fdw.c.

{
    Var        *var;
 
    /*
     * In postgres_fdw, what we need is the ctid, same as for a regular table.
     */
 
    /* Make a Var representing the desired value */
    var = makeVar(rtindex,
                  SelfItemPointerAttributeNumber,
                  TIDOID,
                  -1,
                  InvalidOid,
                  0);
 
    /* Register it as a row-identity column needed by this target rel */
    add_row_identity_var(root, var, rtindex, "ctid");
}

References add_row_identity_var(), InvalidOid, makeVar(), root, and SelfItemPointerAttributeNumber.

Enumerations
enum	FdwScanPrivateIndex { FdwScanPrivateSelectSql , FdwScanPrivateRetrievedAttrs , FdwScanPrivateFetchSize , FdwScanPrivateRelations }

enum	FdwModifyPrivateIndex { FdwModifyPrivateUpdateSql , FdwModifyPrivateTargetAttnums , FdwModifyPrivateLen , FdwModifyPrivateHasReturning , FdwModifyPrivateRetrievedAttrs }

enum	FdwDirectModifyPrivateIndex { FdwDirectModifyPrivateUpdateSql , FdwDirectModifyPrivateHasReturning , FdwDirectModifyPrivateRetrievedAttrs , FdwDirectModifyPrivateSetProcessed }

enum	FdwPathPrivateIndex { FdwPathPrivateHasFinalSort , FdwPathPrivateHasLimit }

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ DEFAULT_FDW_SORT_MULTIPLIER

◆ DEFAULT_FDW_STARTUP_COST

◆ DEFAULT_FDW_TUPLE_COST

Typedef Documentation

◆ ConversionLocation

◆ PgFdwAnalyzeState

◆ PgFdwDirectModifyState

◆ PgFdwModifyState

◆ PgFdwScanState

Enumeration Type Documentation

◆ FdwDirectModifyPrivateIndex

◆ FdwModifyPrivateIndex

◆ FdwPathPrivateIndex

◆ FdwScanPrivateIndex

Function Documentation

◆ add_foreign_final_paths()

◆ add_foreign_grouping_paths()

◆ add_foreign_ordered_paths()

◆ add_paths_with_pathkeys_for_rel()

◆ adjust_foreign_grouping_path_cost()

◆ analyze_row_processor()

◆ apply_returning_filter()

◆ apply_server_options()

◆ apply_table_options()

◆ build_remote_returning()

◆ close_cursor()

◆ complete_pending_request()

◆ conversion_error_callback()

◆ convert_prep_stmt_params()

◆ create_cursor()

◆ create_foreign_modify()

◆ deallocate_query()

◆ ec_member_matches_foreign()

◆ estimate_path_cost_size()

◆ execute_dml_stmt()

◆ execute_foreign_modify()

◆ fetch_more_data()

◆ fetch_more_data_begin()

◆ find_em_for_rel()

◆ find_em_for_rel_target()

◆ find_modifytable_subplan()

◆ finish_foreign_modify()

◆ foreign_grouping_ok()

◆ foreign_join_ok()

◆ get_batch_size_option()

◆ get_remote_estimate()

◆ get_returning_data()

◆ get_tupdesc_for_join_scan_tuples()

◆ get_useful_ecs_for_relation()

◆ get_useful_pathkeys_for_relation()

◆ init_returning_filter()

◆ make_tuple_from_result_row()

◆ merge_fdw_options()

◆ PG_FUNCTION_INFO_V1()

◆ PG_MODULE_MAGIC_EXT()

◆ postgres_fdw_handler()

◆ postgresAcquireSampleRowsFunc()

◆ postgresAddForeignUpdateTargets()

◆ postgresAnalyzeForeignTable()

◆ postgresBeginDirectModify()

◆ postgresBeginForeignInsert()

◆ postgresBeginForeignModify()

◆ postgresBeginForeignScan()

◆ postgresEndDirectModify()

◆ postgresEndForeignInsert()

◆ postgresEndForeignModify()

◆ postgresEndForeignScan()

◆ postgresExecForeignBatchInsert()

◆ postgresExecForeignDelete()

◆ postgresExecForeignInsert()

◆ postgresExecForeignTruncate()

◆ postgresExecForeignUpdate()

◆ postgresExplainDirectModify()

◆ postgresExplainForeignModify()