contrib/postgres_fdw/postgres_fdw.h

   1 /*-------------------------------------------------------------------------
   2  *
   3  * postgres_fdw.h
   4  *                Foreign-data wrapper for remote PostgreSQL servers
   5  *
   6  * Portions Copyright (c) 2012-2023, PostgreSQL Global Development Group
   7  *
   8  * IDENTIFICATION
   9  *                contrib/postgres_fdw/postgres_fdw.h
  10  *
  11  *-------------------------------------------------------------------------
  12  */
  13 #ifndef POSTGRES_FDW_H
  14 #define POSTGRES_FDW_H
  15
  16 #include "foreign/foreign.h"
  17 #include "lib/stringinfo.h"
  18 #include "libpq-fe.h"
  19 #include "nodes/execnodes.h"
  20 #include "nodes/pathnodes.h"
  21 #include "utils/relcache.h"
  22
  23 /*
  24  * FDW-specific planner information kept in RelOptInfo.fdw_private for a
  25  * postgres_fdw foreign table.  For a baserel, this struct is created by
  26  * postgresGetForeignRelSize, although some fields are not filled till later.
  27  * postgresGetForeignJoinPaths creates it for a joinrel, and
  28  * postgresGetForeignUpperPaths creates it for an upperrel.
  29  */
  30 typedef struct PgFdwRelationInfo
  31 {
  32         /*
  33          * True means that the relation can be pushed down. Always true for simple
  34          * foreign scan.
  35          */
  36         bool            pushdown_safe;
  37
  38         /*
  39          * Restriction clauses, divided into safe and unsafe to pushdown subsets.
  40          * All entries in these lists should have RestrictInfo wrappers; that
  41          * improves efficiency of selectivity and cost estimation.
  42          */
  43         List       *remote_conds;
  44         List       *local_conds;
  45
  46         /* Actual remote restriction clauses for scan (sans RestrictInfos) */
  47         List       *final_remote_exprs;
  48
  49         /* Bitmap of attr numbers we need to fetch from the remote server. */
  50         Bitmapset  *attrs_used;
  51
  52         /* True means that the query_pathkeys is safe to push down */
  53         bool            qp_is_pushdown_safe;
  54
  55         /* Cost and selectivity of local_conds. */
  56         QualCost        local_conds_cost;
  57         Selectivity local_conds_sel;
  58
  59         /* Selectivity of join conditions */
  60         Selectivity joinclause_sel;
  61
  62         /* Estimated size and cost for a scan, join, or grouping/aggregation. */
  63         double          rows;
  64         int                     width;
  65         Cost            startup_cost;
  66         Cost            total_cost;
  67
  68         /*
  69          * Estimated number of rows fetched from the foreign server, and costs
  70          * excluding costs for transferring those rows from the foreign server.
  71          * These are only used by estimate_path_cost_size().
  72          */
  73         double          retrieved_rows;
  74         Cost            rel_startup_cost;
  75         Cost            rel_total_cost;
  76
  77         /* Options extracted from catalogs. */
  78         bool            use_remote_estimate;
  79         Cost            fdw_startup_cost;
  80         Cost            fdw_tuple_cost;
  81         List       *shippable_extensions;       /* OIDs of shippable extensions */
  82         bool            async_capable;
  83
  84         /* Cached catalog information. */
  85         ForeignTable *table;
  86         ForeignServer *server;
  87         UserMapping *user;                      /* only set in use_remote_estimate mode */
  88
  89         int                     fetch_size;             /* fetch size for this remote table */
  90
  91         /*
  92          * Name of the relation, for use while EXPLAINing ForeignScan.  It is used
  93          * for join and upper relations but is set for all relations.  For a base
  94          * relation, this is really just the RT index as a string; we convert that
  95          * while producing EXPLAIN output.  For join and upper relations, the name
  96          * indicates which base foreign tables are included and the join type or
  97          * aggregation type used.
  98          */
  99         char       *relation_name;
 100
 101         /* Join information */
 102         RelOptInfo *outerrel;
 103         RelOptInfo *innerrel;
 104         JoinType        jointype;
 105         /* joinclauses contains only JOIN/ON conditions for an outer join */
 106         List       *joinclauses;        /* List of RestrictInfo */
 107
 108         /* Upper relation information */
 109         UpperRelationKind stage;
 110
 111         /* Grouping information */
 112         List       *grouped_tlist;
 113
 114         /* Subquery information */
 115         bool            make_outerrel_subquery; /* do we deparse outerrel as a
 116                                                                                  * subquery? */
 117         bool            make_innerrel_subquery; /* do we deparse innerrel as a
 118                                                                                  * subquery? */
 119         Relids          lower_subquery_rels;    /* all relids appearing in lower
 120                                                                                  * subqueries */
 121
 122         /*
 123          * Index of the relation.  It is used to create an alias to a subquery
 124          * representing the relation.
 125          */
 126         int                     relation_index;
 127 } PgFdwRelationInfo;
 128
 129 /*
 130  * Extra control information relating to a connection.
 131  */
 132 typedef struct PgFdwConnState
 133 {
 134         AsyncRequest *pendingAreq;      /* pending async request */
 135 } PgFdwConnState;
 136
 137 /*
 138  * Method used by ANALYZE to sample remote rows.
 139  */
 140 typedef enum PgFdwSamplingMethod
 141 {
 142         ANALYZE_SAMPLE_OFF,                     /* no remote sampling */
 143         ANALYZE_SAMPLE_AUTO,            /* choose by server version */
 144         ANALYZE_SAMPLE_RANDOM,          /* remote random() */
 145         ANALYZE_SAMPLE_SYSTEM,          /* TABLESAMPLE system */
 146         ANALYZE_SAMPLE_BERNOULLI        /* TABLESAMPLE bernoulli */
 147 } PgFdwSamplingMethod;
 148
 149 /* in postgres_fdw.c */
 150 extern int      set_transmission_modes(void);
 151 extern void reset_transmission_modes(int nestlevel);
 152 extern void process_pending_request(AsyncRequest *areq);
 153
 154 /* in connection.c */
 155 extern PGconn *GetConnection(UserMapping *user, bool will_prep_stmt,
 156                                                          PgFdwConnState **state);
 157 extern void ReleaseConnection(PGconn *conn);
 158 extern unsigned int GetCursorNumber(PGconn *conn);
 159 extern unsigned int GetPrepStmtNumber(PGconn *conn);
 160 extern void do_sql_command(PGconn *conn, const char *sql);
 161 extern PGresult *pgfdw_get_result(PGconn *conn, const char *query);
 162 extern PGresult *pgfdw_exec_query(PGconn *conn, const char *query,
 163                                                                   PgFdwConnState *state);
 164 extern void pgfdw_report_error(int elevel, PGresult *res, PGconn *conn,
 165                                                            bool clear, const char *sql);
 166
 167 /* in option.c */
 168 extern int      ExtractConnectionOptions(List *defelems,
 169                                                                          const char **keywords,
 170                                                                          const char **values);
 171 extern List *ExtractExtensionList(const char *extensionsString,
 172                                                                   bool warnOnMissing);
 173 extern char *process_pgfdw_appname(const char *appname);
 174 extern char *pgfdw_application_name;
 175
 176 /* in deparse.c */
 177 extern void classifyConditions(PlannerInfo *root,
 178                                                            RelOptInfo *baserel,
 179                                                            List *input_conds,
 180                                                            List **remote_conds,
 181                                                            List **local_conds);
 182 extern bool is_foreign_expr(PlannerInfo *root,
 183                                                         RelOptInfo *baserel,
 184                                                         Expr *expr);
 185 extern bool is_foreign_param(PlannerInfo *root,
 186                                                          RelOptInfo *baserel,
 187                                                          Expr *expr);
 188 extern bool is_foreign_pathkey(PlannerInfo *root,
 189                                                            RelOptInfo *baserel,
 190                                                            PathKey *pathkey);
 191 extern void deparseInsertSql(StringInfo buf, RangeTblEntry *rte,
 192                                                          Index rtindex, Relation rel,
 193                                                          List *targetAttrs, bool doNothing,
 194                                                          List *withCheckOptionList, List *returningList,
 195                                                          List **retrieved_attrs, int *values_end_len);
 196 extern void rebuildInsertSql(StringInfo buf, Relation rel,
 197                                                          char *orig_query, List *target_attrs,
 198                                                          int values_end_len, int num_params,
 199                                                          int num_rows);
 200 extern void deparseUpdateSql(StringInfo buf, RangeTblEntry *rte,
 201                                                          Index rtindex, Relation rel,
 202                                                          List *targetAttrs,
 203                                                          List *withCheckOptionList, List *returningList,
 204                                                          List **retrieved_attrs);
 205 extern void deparseDirectUpdateSql(StringInfo buf, PlannerInfo *root,
 206                                                                    Index rtindex, Relation rel,
 207                                                                    RelOptInfo *foreignrel,
 208                                                                    List *targetlist,
 209                                                                    List *targetAttrs,
 210                                                                    List *remote_conds,
 211                                                                    List **params_list,
 212                                                                    List *returningList,
 213                                                                    List **retrieved_attrs);
 214 extern void deparseDeleteSql(StringInfo buf, RangeTblEntry *rte,
 215                                                          Index rtindex, Relation rel,
 216                                                          List *returningList,
 217                                                          List **retrieved_attrs);
 218 extern void deparseDirectDeleteSql(StringInfo buf, PlannerInfo *root,
 219                                                                    Index rtindex, Relation rel,
 220                                                                    RelOptInfo *foreignrel,
 221                                                                    List *remote_conds,
 222                                                                    List **params_list,
 223                                                                    List *returningList,
 224                                                                    List **retrieved_attrs);
 225 extern void deparseAnalyzeSizeSql(StringInfo buf, Relation rel);
 226 extern void deparseAnalyzeInfoSql(StringInfo buf, Relation rel);
 227 extern void deparseAnalyzeSql(StringInfo buf, Relation rel,
 228                                                           PgFdwSamplingMethod sample_method,
 229                                                           double sample_frac,
 230                                                           List **retrieved_attrs);
 231 extern void deparseTruncateSql(StringInfo buf,
 232                                                            List *rels,
 233                                                            DropBehavior behavior,
 234                                                            bool restart_seqs);
 235 extern void deparseStringLiteral(StringInfo buf, const char *val);
 236 extern EquivalenceMember *find_em_for_rel(PlannerInfo *root,
 237                                                                                   EquivalenceClass *ec,
 238                                                                                   RelOptInfo *rel);
 239 extern EquivalenceMember *find_em_for_rel_target(PlannerInfo *root,
 240                                                                                                  EquivalenceClass *ec,
 241                                                                                                  RelOptInfo *rel);
 242 extern List *build_tlist_to_deparse(RelOptInfo *foreignrel);
 243 extern void deparseSelectStmtForRel(StringInfo buf, PlannerInfo *root,
 244                                                                         RelOptInfo *rel, List *tlist,
 245                                                                         List *remote_conds, List *pathkeys,
 246                                                                         bool has_final_sort, bool has_limit,
 247                                                                         bool is_subquery,
 248                                                                         List **retrieved_attrs, List **params_list);
 249 extern const char *get_jointype_name(JoinType jointype);
 250
 251 /* in shippable.c */
 252 extern bool is_builtin(Oid objectId);
 253 extern bool is_shippable(Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo);
 254
 255 #endif                                                  /* POSTGRES_FDW_H */