diff --git a/contrib/Makefile b/contrib/Makefile index 2b31450..3eab73d 100644 --- a/contrib/Makefile +++ b/contrib/Makefile @@ -41,6 +41,7 @@ SUBDIRS = \ pgcrypto \ pgrowlocks \ pgstattuple \ + postgresql_fdw \ seg \ spi \ tablefunc \ diff --git a/contrib/README b/contrib/README index 3c4e324..ccee6a4 100644 --- a/contrib/README +++ b/contrib/README @@ -159,6 +159,9 @@ pgstattuple - space within a table by Tatsuo Ishii +postgresql_fdw - + Foreign-data wrapper for external PostgreSQL servers + seg - Confidence-interval datatype (GiST indexing example) by Gene Selkov, Jr. diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c index 19b98fb..b1509dc 100644 --- a/contrib/dblink/dblink.c +++ b/contrib/dblink/dblink.c @@ -2309,6 +2309,9 @@ get_connect_string(const char *servername) { DefElem *def = lfirst(cell); + if (!is_libpq_connection_option(def->defname)) + continue; + appendStringInfo(buf, "%s='%s' ", def->defname, escape_param_str(strVal(def->arg))); } @@ -2317,6 +2320,9 @@ get_connect_string(const char *servername) { DefElem *def = lfirst(cell); + if (!is_libpq_connection_option(def->defname)) + continue; + appendStringInfo(buf, "%s='%s' ", def->defname, escape_param_str(strVal(def->arg))); } @@ -2326,6 +2332,9 @@ get_connect_string(const char *servername) DefElem *def = lfirst(cell); + if (!is_libpq_connection_option(def->defname)) + continue; + appendStringInfo(buf, "%s='%s' ", def->defname, escape_param_str(strVal(def->arg))); } diff --git a/contrib/postgresql_fdw/.gitignore b/contrib/postgresql_fdw/.gitignore new file mode 100644 index 0000000..4a8bf17 --- /dev/null +++ b/contrib/postgresql_fdw/.gitignore @@ -0,0 +1,3 @@ +/postgresql_fdw.sql +# Generated subdirectories +/results/ diff --git a/contrib/postgresql_fdw/Makefile b/contrib/postgresql_fdw/Makefile new file mode 100644 index 0000000..b9cf9ec --- /dev/null +++ b/contrib/postgresql_fdw/Makefile @@ -0,0 +1,22 @@ +# contrib/postgresql_fdw/Makefile + +MODULE_big = postgresql_fdw +PG_CPPFLAGS = -I$(libpq_srcdir) +OBJS = postgresql_fdw.o +SHLIB_LINK = $(libpq) + +DATA_built = postgresql_fdw.sql +DATA = uninstall_postgresql_fdw.sql +REGRESS = postgresql_fdw + + +ifdef USE_PGXS +PG_CONFIG = pg_config +PGXS := $(shell $(PG_CONFIG) --pgxs) +include $(PGXS) +else +subdir = contrib/postgresql_fdw +top_builddir = ../.. +include $(top_builddir)/src/Makefile.global +include $(top_srcdir)/contrib/contrib-global.mk +endif diff --git a/contrib/postgresql_fdw/expected/postgresql_fdw.out b/contrib/postgresql_fdw/expected/postgresql_fdw.out new file mode 100644 index 0000000..bcc6a3c --- /dev/null +++ b/contrib/postgresql_fdw/expected/postgresql_fdw.out @@ -0,0 +1,116 @@ +SET SEARCH_PATH = public; +SET DATESTYLE = 'Postgres, MDY'; +-- ============================================================================= +-- Prepare section +-- ============================================================================= +-- connect database for regression test +\c contrib_regression +-- install postgresql_fdw module +SET client_min_messages = warning; +\set ECHO none +-- define fdw-related objects +CREATE SERVER loopback1 FOREIGN DATA WRAPPER postgresql_fdw + OPTIONS (dbname 'contrib_regression'); +CREATE SERVER loopback2 FOREIGN DATA WRAPPER postgresql_fdw + OPTIONS (dbname 'contrib_regression'); +CREATE USER MAPPING FOR PUBLIC SERVER loopback1; +CREATE USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (user 'invalid'); +CREATE TABLE t1( + c1 integer, + c2 text, + c3 date +); +COPY t1 FROM stdin; +CREATE TABLE t2( + c1 integer, + c2 text, + c3 date +); +COPY t2 FROM stdin; +CREATE FOREIGN TABLE ft1 ( + c1 integer OPTIONS (colname 'invalid'), + c2 text OPTIONS (colname 'C2'), + c3 date +) SERVER loopback1 OPTIONS (relname 't1'); +ALTER FOREIGN TABLE ft1 ALTER COLUMN c1 OPTIONS (SET colname 'C1'); +ALTER FOREIGN TABLE ft1 ALTER COLUMN c2 OPTIONS (DROP colname); +CREATE FOREIGN TABLE ft2 ( + c1 integer, + c2 text, + c3 date +) SERVER loopback2 OPTIONS (relname 'invalid'); +-- simple query and connection caching +SELECT ft1.* FROM ft1 ORDER BY c1; + c1 | c2 | c3 +----+-----+------------ + 1 | foo | 01-01-1970 + 2 | bar | 01-02-1970 + 3 | buz | 01-03-1970 +(3 rows) + +SELECT * FROM ft2 ORDER BY c1; -- ERROR +ERROR: could not connect to server "loopback2" +DETAIL: FATAL: role "invalid" does not exist + +ALTER USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (DROP user); +SELECT * FROM ft2 ORDER BY c1; -- ERROR +ERROR: could not execute foreign query +DETAIL: ERROR: relation "public.invalid" does not exist +LINE 1: SELECT c1, c2, c3 FROM public.invalid ft2 + ^ + +HINT: SELECT c1, c2, c3 FROM public.invalid ft2 +ALTER FOREIGN TABLE ft2 OPTIONS (SET relname 't2'); +SELECT * FROM ft2 ORDER BY c1; + c1 | c2 | c3 +----+-----+------------ + 1 | foo | 01-01-1970 + 12 | bar | 01-02-1970 + 13 | buz | 01-03-1970 +(3 rows) + +-- join two foreign tables +SELECT * FROM ft1 JOIN ft2 ON (ft1.c1 = ft2.c1) ORDER BY ft1.c1; + c1 | c2 | c3 | c1 | c2 | c3 +----+-----+------------+----+-----+------------ + 1 | foo | 01-01-1970 | 1 | foo | 01-01-1970 +(1 row) + +-- join itself +SELECT * FROM ft1 t1 JOIN ft1 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1; + c1 | c2 | c3 | c1 | c2 | c3 +----+-----+------------+----+-----+------------ + 1 | foo | 01-01-1970 | 1 | foo | 01-01-1970 + 2 | bar | 01-02-1970 | 2 | bar | 01-02-1970 + 3 | buz | 01-03-1970 | 3 | buz | 01-03-1970 +(3 rows) + +-- outer join +SELECT * FROM ft1 t1 LEFT JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY 1,2,3,4,5,6; + c1 | c2 | c3 | c1 | c2 | c3 +----+-----+------------+----+-----+------------ + 1 | foo | 01-01-1970 | 1 | foo | 01-01-1970 + 2 | bar | 01-02-1970 | | | + 3 | buz | 01-03-1970 | | | +(3 rows) + +-- WHERE clause push-down +set client_min_messages = debug1; +SELECT * FROM ft1 WHERE c1 = 1 AND c2 = lower('FOO') AND c3 < now(); +DEBUG: deparsed SQL is "SELECT C1, c2, c3 FROM public.t1 ft1 WHERE ((c1 = 1) AND (c2 = 'foo'::text))" + c1 | c2 | c3 +----+-----+------------ + 1 | foo | 01-01-1970 +(1 row) + +reset client_min_messages; +-- clean up +DROP FOREIGN DATA WRAPPER postgresql_fdw CASCADE; +NOTICE: drop cascades to 6 other objects +DETAIL: drop cascades to server loopback1 +drop cascades to user mapping for public +drop cascades to foreign table ft1 +drop cascades to server loopback2 +drop cascades to user mapping for public +drop cascades to foreign table ft2 +DROP TABLE t1 CASCADE; diff --git a/contrib/postgresql_fdw/postgresql_fdw.c b/contrib/postgresql_fdw/postgresql_fdw.c new file mode 100644 index 0000000..4522d31 --- /dev/null +++ b/contrib/postgresql_fdw/postgresql_fdw.c @@ -0,0 +1,972 @@ +/*------------------------------------------------------------------------- + * + * postgresql_fdw.c + * foreign-data wrapper for PostgreSQL + * + * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group + * + * IDENTIFICATION + * contrib/postgresql_fdw/postgresql_fdw.c + * + *------------------------------------------------------------------------- + */ +#include "postgres.h" + +#include "catalog/pg_namespace.h" +#include "catalog/pg_operator.h" +#include "catalog/pg_proc.h" +#include "foreign/foreign.h" +#include "funcapi.h" +#include "libpq-fe.h" +#include "mb/pg_wchar.h" +#include "miscadmin.h" +#include "nodes/makefuncs.h" +#include "nodes/nodeFuncs.h" +#include "nodes/relation.h" +#include "optimizer/clauses.h" +#include "optimizer/cost.h" +#include "parser/parsetree.h" +#include "parser/scansup.h" +#include "utils/builtins.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/resowner.h" +#include "utils/syscache.h" + +#include "postgresql_fdw.h" + +PG_MODULE_MAGIC; + + +/* + * PostgreSQL specific portion of a foreign query request + */ +typedef struct pgFdwExecutionState +{ + PGconn *conn; + PGresult *res; + List *colmap; + int nextrow; +} pgFdwExecutionState; + +extern Datum postgresql_fdw_handler(PG_FUNCTION_ARGS); + +/* + * FDW routines + */ +static FdwPlan *pgPlanRelScan(Oid foreigntableid, PlannerInfo *root, + RelOptInfo *baserel); +static FdwExecutionState *pgBeginScan(FdwPlan *plan, ParamListInfo params); +static void pgIterate(FdwExecutionState *state, TupleTableSlot *slot); +static void pgReScan(FdwExecutionState *state); +static void pgEndScan(FdwExecutionState *state); + +/* helper for deparsing a request into SQL statement */ + +static bool is_foreign_qual(PlannerInfo *root, RelOptInfo *baserel, Expr *expr); +static char *deparseSql(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel, List **colmap); + +static void storeResult(pgFdwExecutionState *priv, TupleTableSlot *slot, int rowno); + +/* + * Connection management + */ +static PGconn *GetConnection(ForeignServer *server, UserMapping *user); +static void ReleaseConnection(PGconn *conn); +static void check_conn_params(const char **keywords, const char **values); +static PGconn *connect_pg_server(ForeignServer *server, UserMapping *user); +static void cleanup_connection(ResourceReleasePhase phase, + bool isCommit, + bool isTopLevel, + void *arg); + +/* + * FdwRoutine of PostgreSQL wrapper + */ +static FdwRoutine postgresql_fdw_routine = +{ + pgPlanRelScan, + pgBeginScan, + pgIterate, + pgReScan, + pgEndScan +}; + +/* + * return foreign-data wrapper handler object to execute foreign-data wrapper + * routines. + */ +PG_FUNCTION_INFO_V1(postgresql_fdw_handler); +Datum +postgresql_fdw_handler(PG_FUNCTION_ARGS) +{ + PG_RETURN_POINTER(&postgresql_fdw_routine); +} + +static FdwPlan * +pgPlanRelScan(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel) +{ + FdwPlan *plan = makeNode(FdwPlan); + char *sql; + List *colmap; + + sql = deparseSql(foreigntableid, root, baserel, &colmap); + + plan->explainInfo = sql; + plan->fdw_private = list_make2(makeString(sql), colmap); + + return plan; +} + +typedef struct +{ + PlannerInfo *root; + RelOptInfo *foreignrel; +} remotely_executable_cxt; + +static bool +is_proc_remotely_executable(Oid procid) +{ + /* assume that only built-in functions can be pushed down */ + if (get_func_namespace(procid) != PG_CATALOG_NAMESPACE) + return false; + /* we don't check volatility here, that's done once at the top-level */ + + return true; +} + +static bool +is_not_remotely_executable_walker(Node *node, remotely_executable_cxt *context) +{ + if (node == NULL) + return false; + + if (IsA(node, Query)) + return true; + + switch (nodeTag(node)) + { + case T_Query: + /* give up on subqueries */ + return true; + case T_Param: + /* TODO: pass internal parameters to the foreign server */ + { + ParamKind paramkind = ((Param *) node)->paramkind; + elog(DEBUG1, "%s() param=%s", __FUNCTION__, + paramkind == PARAM_EXTERN ? "PARAM_EXTERN" : + paramkind == PARAM_EXEC ? "PARAM_EXEC" : + paramkind == PARAM_SUBLINK ? "PARAM_SUBLINK" : "unkown"); + } + if (((Param *) node)->paramkind != PARAM_EXTERN) + return true; + break; + case T_OpExpr: + { + OpExpr *op = (OpExpr *) node; + if (!is_proc_remotely_executable(op->opfuncid)) + return true; + else + return false; + } + case T_FuncExpr: + { + FuncExpr *fe = (FuncExpr *) node; + if (!is_proc_remotely_executable(fe->funcid)) + return true; + else + return false; + } + + case T_TargetEntry: + case T_PlaceHolderVar: + case T_AppendRelInfo: + case T_PlaceHolderInfo: + /* TODO: research whether those complex nodes are evaluatable. */ + return true; + case T_Var: + { + Var *var = (Var *) node; + if (var->varno != context->foreignrel->relid || var->varlevelsup != 0) + return true; + else + return false; + } + + default: + break; + } + + return expression_tree_walker(node, is_not_remotely_executable_walker, + context); +} + + +/* + * Check whether the ExprState node can be evaluated in foreign server. + * + * An expression which consists of expressions below can be evaluated in + * the foreign server. + * - constant value + * - variable (foreign table column) + * - external parameter (parameter of prepared statement) + * - array + * - bool expression (AND/OR/NOT) + * - NULL test (IS [NOT] NULL) + * - operator + * - IMMUTABLE only + * - It is required that the meaning of the operator be the same as the + * local server in the foreign server. + * - function + * - IMMUTABLE only + * - It is required that the meaning of the operator be the same as the + * local server in the foreign server. + * - scalar array operator (ANY/ALL) + */ +static bool +is_foreign_qual(PlannerInfo *root, RelOptInfo *baserel, Expr *expr) +{ + remotely_executable_cxt context; + + context.root = root; + context.foreignrel = baserel; + if (is_not_remotely_executable_walker((Node *) expr, &context)) + return false; + if (contain_volatile_functions((Node *) expr)) + return false; + + return true; +} + +/* + * Deparse query request into SQL statement. + * + * If an expression in PlanState.qual list satisfies is_foreign_qual(), the + * expression is: + * - deparsed into WHERE clause of remote SQL statement to evaluate that + * expression on remote side + * - removed from PlanState.qual list to avoid duplicate evaluation, on + * remote side and local side + */ +static char * +deparseSql(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel, + List **colmap) +{ + List *context; + StringInfoData sql; + ForeignTable *table = GetForeignTable(foreigntableid); + ListCell *lc; + char *nspname = NULL; + char *relname = NULL; + bool *requiredatts; + RangeTblEntry *rte; + AttrNumber attno; + + /* extract ForeignScan and RangeTblEntry */ + + /* prepare to deparse plan */ + initStringInfo(&sql); + + /* + * deparse SELECT target list. We only fetch the necessary columns from + * the remote server, but the result tuple needs to include all columns. + * So we need a mapping of the columns actually fetched to the full + * row type of the relation. Build that map here too. + */ + *colmap = NIL; + appendStringInfoString(&sql, "SELECT "); + requiredatts = palloc0((baserel->max_attr + 1) * sizeof(bool)); + foreach (lc, baserel->reltargetlist) + { + Var *var = lfirst(lc); + + if (var->varlevelsup != 0) + elog(ERROR, "unexpected varlevelsup: %d", var->varlevelsup); + if (var->varno != baserel->relid) + elog(ERROR, "reference to another relation in reltargetlist"); + if (var->varattno < 0) + elog(ERROR, "fetching remote system attributes is not supported"); + if (var->varattno > baserel->max_attr) + elog(ERROR, "unexpected attribute number %d", var->varattno); + + requiredatts[var->varattno] = true; + } + + /* whole row */ + if (requiredatts[0] == true) + MemSet(requiredatts, true, baserel->max_attr + 1); + + rte = rt_fetch(baserel->relid, root->parse->rtable); + for (attno = 1; attno <= baserel->max_attr; attno++) + { + if (requiredatts[attno]) + { + char *attname; + + if (*colmap != NIL) + appendStringInfoString(&sql, ", "); + + attname = get_rte_attribute_name(rte, attno); + appendStringInfoString(&sql, quote_identifier(attname)); + + *colmap = lappend_int(*colmap, attno); + } + } + + /* + * Deparse FROM + * + * If the foreign table has generic option "nspname" and/or "relname", use + * them in the foreign query. Otherwise, use local catalog names. + */ + foreach(lc, table->options) + { + DefElem *opt = lfirst(lc); + if (strcmp(opt->defname, "nspname") == 0) + nspname = pstrdup(strVal(opt->arg)); + else if (strcmp(opt->defname, "relname") == 0) + relname = pstrdup(strVal(opt->arg)); + } + if (nspname == NULL) + nspname = get_namespace_name(get_rel_namespace(foreigntableid)); + if (relname == NULL) + relname = get_rel_name(foreigntableid); + appendStringInfo(&sql, " FROM %s.%s", + quote_identifier(nspname), + quote_identifier(relname)); + + + /* + * deparse WHERE cluase + * + * The expressions which satisfy is_foreign_qual() are deparsed into WHERE + * clause of result SQL string, and they could be removed from qual of + * PlanState to avoid duplicate evaluation at ExecScan(). + * + * We never change the qual in the Plan node which was made by PREPARE + * statement to make following EXECUTE statements work properly. The Plan + * node is used repeatedly to create PlanState for each EXECUTE statement. + */ + if (baserel->baserestrictinfo) + { + List *local_qual = NIL; + List *foreign_expr = NIL; + ListCell *lc; + + /* + * Divide qual of PlanState into two lists, one for local evaluation + * and one for foreign evaluation. + */ + foreach (lc, baserel->baserestrictinfo) + { + RestrictInfo *ri = (RestrictInfo *) lfirst(lc); + + if (is_foreign_qual(root, baserel, ri->clause)) + { + /* XXX: deparse and add to sql here */ + foreign_expr = lappend(foreign_expr, ri->clause); + } + else + local_qual = lappend(local_qual, ri); + } + /* + * XXX: If the remote side is not reliable enough, we can keep the qual + * in PlanState as is and evaluate them on local side too. If so, just + * omit replacement below. + */ + baserel->baserestrictinfo = local_qual; + + /* + * Deparse quals to be evaluated in the foreign server if any. + * TODO: modify deparse_expression() to deparse conditions which use + * internal parameters. + */ + if (foreign_expr != NIL) + { + Node *node; + + context = deparse_context_for("foreigntable", foreigntableid); + + node = (Node *) make_ands_explicit(foreign_expr); + node = copyObject(node); + + /* + * XXX: deparse_context_for creates a context where the relation + * is relation no 1 in the range table. But the quals we have + * use something else to refer to this foreign table. Make a + * temporary copy of the quals and adjust varnos to 1. + */ + OffsetVarNodes(node, 1 - baserel->relid, 0); + appendStringInfo(&sql, " WHERE %s", + deparse_expression(node, context, false, false)); + /* + * The contents of the list MUST NOT be free-ed because they are + * referenced from Plan.qual list. + */ + list_free(foreign_expr); + } + } + + elog(DEBUG1, "deparsed SQL is \"%s\"", sql.data); + + return sql.data; +} + +/* + * Initiate actual scan on a foreign table. + * This function is called just after pgOpen() if the ForeignScan was executed + * for a real query or EXPLAIN statement with ANALYZE option. + */ +static FdwExecutionState * +pgBeginScan(FdwPlan *plan, ParamListInfo params) +{ + FdwExecutionState *result = palloc(sizeof(FdwExecutionState)); + pgFdwExecutionState *state; + PGconn *conn; + PGresult *res; + int numParams = params ? params->numParams : 0; + Oid *types = NULL; + const char **values = NULL; + const char *sql = strVal(linitial((List *) plan->fdw_private)); + List *colmap = lsecond((List *) plan->fdw_private); + + state = palloc(sizeof(pgFdwExecutionState)); + state->colmap = colmap; + + conn = GetConnection(GetForeignServer(plan->serverid), + GetUserMapping(plan->userid, plan->serverid)); + state->conn = conn; + + result->fdw_private = state; + + elog(DEBUG3, "%s() called", __FUNCTION__); + + /* construct parameter array in text format */ + /* TODO: omit unused parameter */ + if (numParams > 0) + { + int i; + + types = palloc0(sizeof(Oid) * numParams); + values = palloc0(sizeof(char *) * numParams); + for (i = 0; i < numParams; i++) + { + types[i] = params->params[i].ptype; + if (params->params[i].isnull) + values[i] = NULL; + else + { + Oid out_func_oid; + bool isvarlena; + FmgrInfo func; + + /* TODO: cache FmgrInfo to use it again after pgReOpen() */ + /* TODO: send parameters in binary format rather than text */ + getTypeOutputInfo(types[i], &out_func_oid, &isvarlena); + fmgr_info(out_func_oid, &func); + values[i] = + OutputFunctionCall(&func, params->params[i].value); + } + } + } + + /* + * Execute query with the parameters. + * TODO: support internal parameters(PARAM_EXTERN) + * TODO: support cursor mode for huge result sets. + */ + res = PQexecParams(conn, sql, numParams, types, values, NULL, NULL, 0); + if (numParams > 0) + { + int i; + pfree(types); + for (i = 0; i < numParams; i++) + pfree((char *) values[i]); + pfree(values); + } + + /* + * If the query has failed, reporting details is enough here. + * Connections which are used by this query (including other scans) will + * be cleaned up by the foreign connection manager. + */ + if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) + { + char *msg; + + msg = pstrdup(PQerrorMessage(conn)); + PQclear(res); + ereport(ERROR, + (errmsg("could not execute foreign query"), + errdetail("%s", msg), + errhint("%s", sql))); + } + + state->res = res; + state->nextrow = 0; + + return result; +} + +/* + * return tuples one by one. + * - execute SQL statement which was deparsed in pgOpen() + * + * The all of result are fetched at once when pgIterate() is called first after + * pgOpen() or pgReOpen(). + * pgIterate() moves the next tuple from tupstore to TupleTableSlot in + * ScanState. + */ +static void +pgIterate(FdwExecutionState *state, TupleTableSlot *slot) +{ + pgFdwExecutionState *priv = state->fdw_private; + + elog(DEBUG3, "%s() called", __FUNCTION__); + + if (priv->nextrow == PQntuples(priv->res)) + ExecClearTuple(slot); + else + storeResult(priv, slot, priv->nextrow++); +} + +static void +pgReScan(FdwExecutionState *state) +{ + ((pgFdwExecutionState *)state->fdw_private)->nextrow = 0; +} + +static void +pgEndScan(FdwExecutionState *state) +{ + pgFdwExecutionState *priv = (pgFdwExecutionState *) state->fdw_private; + + PQclear(priv->res); + pfree(priv); +} + +/* + * Store a PGresult into tuplestore. + */ +static void +storeResult(pgFdwExecutionState *priv, TupleTableSlot *slot, int rowno) +{ + int nfields; + char **values; + AttInMetadata *attinmeta; + Form_pg_attribute *attrs; + TupleDesc tupdesc = slot->tts_tupleDescriptor; + HeapTuple tuple; + ListCell *lc; + int i; + + nfields = PQnfields(priv->res); + attrs = tupdesc->attrs; + + /* buffer should include dropped columns */ + values = palloc0(sizeof(char *) * tupdesc->natts); + + /* store tuple in the slot */ + attinmeta = TupleDescGetAttInMetadata(tupdesc); + + i = 0; + foreach(lc, priv->colmap) + { + AttrNumber attno = lfirst_int(lc); + + /* check result and tuple descriptor have the same number of columns */ + if (attno < 1 || attno > tupdesc->natts) + elog(ERROR, "invalid attribute number %d", attno); + + /* skip dropped columns. */ + if (attrs[attno - 1]->attisdropped || + PQgetisnull(priv->res, rowno, i)) + { + values[attno - 1] = NULL; + } + else + values[attno - 1] = PQgetvalue(priv->res, rowno, i); + + i++; + } + + /* build the tuple and put it into the tuplestore. */ + tuple = BuildTupleFromCStrings(attinmeta, values); + ExecStoreTuple(tuple, slot, InvalidBuffer, false /* no need to pfree because we run in the per-tuple context */); + + pfree(values); +} + +#ifdef NOT_USED +/* + * Retrieve cost-factors of the foreign server from catalog. + */ +static void +get_server_costs(Oid relid, double *connection_cost, double *transfer_cost) +{ + ForeignTable *table; + ForeignServer *server; + int n; + const char **keywords; + const char **values; + int i; + + /* + * Retrieve generic options from the target table and its server to correct + * costs. + */ + table = GetForeignTable(relid); + server = GetForeignServer(table->serverid); + n = list_length(table->options) + list_length(server->options) + 1; + keywords = (const char **) palloc(sizeof(char *) * n); + values = (const char **) palloc(sizeof(char *) * n); + n = 0; + n += flatten_generic_options(server->options, keywords + n, values + n); + n += flatten_generic_options(table->options, keywords + n, values + n); + keywords[n] = values[n] = NULL; + + for (i = 0; keywords[i]; i++) + { + if (pg_strcasecmp(keywords[i], "connection_cost") == 0) + *connection_cost = strtod(values[i], NULL); + else if (pg_strcasecmp(keywords[i], "transfer_cost") == 0) + *transfer_cost = strtod(values[i], NULL); + } + + pfree(keywords); + pfree(values); +} +#endif + +/* + * Estimate costs of scanning on a foreign table. + * + * baserel->baserestrictinfo can be used to examine quals on the relation. + */ +static void +pgEstimateCosts(ForeignPath *path, PlannerInfo *root, RelOptInfo *baserel) +{ + RangeTblEntry *rte; + double connection_cost = 0.0; + double transfer_cost = 0.0; + + elog(DEBUG3, "%s() called", __FUNCTION__); + + /* + * Use cost_seqscan() to get approximate value. + */ + cost_seqscan(&path->path, root, baserel); + + /* Get cost factor from catalog to correct costs. */ + rte = planner_rt_fetch(baserel->relid, root); +#ifdef NOT_USED + get_server_costs(rte->relid, &connection_cost, &transfer_cost); +#endif + /* XXX arbitrary guesses */ + connection_cost = 10.0; + transfer_cost = 1.0; + path->path.startup_cost += connection_cost; + path->path.total_cost += connection_cost; + path->path.total_cost += transfer_cost * + path->path.parent->width * path->path.parent->rows; +} + +/* ============================================================================ + * Connection management functions + * ==========================================================================*/ + +/* + * Connection cache entry managed with hash table. + */ +typedef struct ConnCacheEntry +{ + /* hash key must be first */ + char name[NAMEDATALEN]; /* connection name; used as hash key */ + int refs; /* reference counter */ + PGconn *conn; /* foreign server connection */ +} ConnCacheEntry; + +/* + * Hash table which is used to cache connection to PostgreSQL servers, will be + * initialized before first attempt to connect PostgreSQL server by the backend. + */ +static HTAB *FSConnectionHash; + +/* + * Get a PGconn which can be used to execute foreign query on the remote + * PostgreSQL server with the user's authorization. If this was the first + * request for the server, new connection is established. + */ +static PGconn * +GetConnection(ForeignServer *server, UserMapping *user) +{ + const char *conname = server->servername; + bool found; + ConnCacheEntry *entry; + PGconn *conn = NULL; + + /* initialize connection cache if it isn't */ + if (FSConnectionHash == NULL) + { + HASHCTL ctl; + + /* hash key is the name of the connection */ + MemSet(&ctl, 0, sizeof(ctl)); + ctl.keysize = NAMEDATALEN; + ctl.entrysize = sizeof(ConnCacheEntry); + /* allocate FSConnectionHash in the cache context */ + ctl.hcxt = CacheMemoryContext; + FSConnectionHash = hash_create("Foreign Connections", 32, + &ctl, + HASH_ELEM | HASH_CONTEXT); + } + + /* Is there any cached and valid connection with such name? */ + entry = hash_search(FSConnectionHash, conname, HASH_ENTER, &found); + if (found) + { + if (entry->conn != NULL) + { + entry->refs++; + elog(DEBUG3, "ref %d for %s", entry->refs, entry->name); + return entry->conn; + } + + /* + * Connection cache entry was found but connection in it is invalid. + * We reuse entry to store newly established connection later. + */ + } + else + { + /* + * Use ResourceOner to clean the connection up on error including + * user interrupt. + */ + entry->refs = 0; + entry->conn = NULL; + RegisterResourceReleaseCallback(cleanup_connection, entry); + } + + /* + * Here we have to establish new connection. + * Use PG_TRY block to ensure closing connection on error. + */ + PG_TRY(); + { + /* Connect to the foreign PostgreSQL server */ + conn = connect_pg_server(server, user); + + /* + * Initialize the cache entry to keep new connection. + * Note: entry->name has been initialized in hash_search(HASH_ENTER). + */ + entry->refs = 1; + entry->conn = conn; + elog(DEBUG3, "connected to %s (%d)", entry->name, entry->refs); + } + PG_CATCH(); + { + PQfinish(conn); + entry->refs = 0; + entry->conn = NULL; + PG_RE_THROW(); + } + PG_END_TRY(); + + return conn; +} + +/* + * For non-superusers, insist that the connstr specify a password. This + * prevents a password from being picked up from .pgpass, a service file, + * the environment, etc. We don't want the postgres user's passwords + * to be accessible to non-superusers. + */ +static void +check_conn_params(const char **keywords, const char **values) +{ + int i; + + /* no check required if superuser */ + if (superuser()) + return; + + /* ok if params contain a non-empty password */ + for (i = 0; keywords[i] != NULL; i++) + { + if (strcmp(keywords[i], "password") == 0 && values[i][0] != '\0') + return; + } + + ereport(ERROR, + (errcode(ERRCODE_S_R_E_PROHIBITED_SQL_STATEMENT_ATTEMPTED), + errmsg("password is required"), + errdetail("Non-superusers must provide a password in the connection string."))); +} + +static int +flatten_generic_options(List *defelems, const char **keywords, const char **values) +{ + ListCell *lc; + int i; + + i = 0; + foreach(lc, defelems) + { + DefElem *d = (DefElem *) lfirst(lc); + keywords[i] = d->defname; + values[i] = strVal(d->arg); + i++; + } + return i; +} + +static PGconn * +connect_pg_server(ForeignServer *server, UserMapping *user) +{ + const char *conname = server->servername; + PGconn *conn; + const char **all_keywords; + const char **all_values; + const char **keywords; + const char **values; + int n; + int i, j; + + /* + * Construct connection params from generic options of ForeignServer and + * UserMapping. Generic options might not be a one of connection options. + */ + n = list_length(server->options) + list_length(user->options) + 1; + all_keywords = (const char **) palloc(sizeof(char *) * n); + all_values = (const char **) palloc(sizeof(char *) * n); + keywords = (const char **) palloc(sizeof(char *) * n); + values = (const char **) palloc(sizeof(char *) * n); + n = 0; + n += flatten_generic_options(server->options, + all_keywords + n, all_values + n); + n += flatten_generic_options(user->options, + all_keywords + n, all_values + n); + all_keywords[n] = all_values[n] = NULL; + + for (i = 0, j = 0; all_keywords[i]; i++) + { + /* Use only libpq connection options. */ + if (!is_libpq_connection_option(all_keywords[i])) + continue; + keywords[j] = all_keywords[i]; + values[j] = all_values[i]; + j++; + } + keywords[j] = values[j] = NULL; + pfree(all_keywords); + pfree(all_values); + + /* verify connection parameters and do connect */ + check_conn_params(keywords, values); + conn = PQconnectdbParams(keywords, values, 0); + if (!conn || PQstatus(conn) != CONNECTION_OK) + ereport(ERROR, + (errcode(ERRCODE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION), + errmsg("could not connect to server \"%s\"", conname), + errdetail("%s", PQerrorMessage(conn)))); + pfree(keywords); + pfree(values); + + return conn; +} + +/* + * Mark the connection as "unused", and close it if the caller was the last + * user of the connection. + */ +static void +ReleaseConnection(PGconn *conn) +{ + HASH_SEQ_STATUS scan; + ConnCacheEntry *entry; + + if (conn == NULL) + return; + + /* + * We need to scan seqencially since we use the address to find appropriate + * PGconn from the hash table. + */ + hash_seq_init(&scan, FSConnectionHash); + while ((entry = (ConnCacheEntry *) hash_seq_search(&scan))) + { + if (entry->conn == conn) + break; + } + hash_seq_term(&scan); + + /* + * If the released connection was an orphan, just close it. + */ + if (entry == NULL) + { + PQfinish(conn); + return; + } + + /* If the caller was the last referer, unregister it from cache. */ + entry->refs--; + elog(DEBUG3, "ref %d for %s", entry->refs, entry->name); + if (entry->refs == 0) + { + elog(DEBUG3, "closing connection \"%s\"", entry->name); + PQfinish(entry->conn); + entry->refs = 0; + entry->conn = NULL; + } +} + +/* + * Clean the connection up via ResourceOwner when pgClose couldn't close the + * connection gracefully. + */ +static void +cleanup_connection(ResourceReleasePhase phase, + bool isCommit, + bool isTopLevel, + void *arg) +{ + ConnCacheEntry *entry = (ConnCacheEntry *) arg; + + /* + * If the transaction was committed, the connection has been closed via + * pgClose() and ReleaseConnection(). + */ + if (isCommit) + return; + + /* + * We clean the connection up on post-lock because foreign connections are + * backend-internal resource. + */ + if (phase != RESOURCE_RELEASE_AFTER_LOCKS) + return; + + /* + * We ignore cleanup for ResourceOwners other than transaction. At this + * point, such a ResourceOwner is only Portal. + */ + if (CurrentResourceOwner != CurTransactionResourceOwner) + return; + + /* + * We don't care whether we are in TopTransaction or Subtransaction. + * Anyway, we close the connection and reset the reference counter. + */ + if (entry->conn != NULL) + { + elog(DEBUG3, "closing connection to %s", entry->name); + PQfinish(entry->conn); + entry->refs = 0; + entry->conn = NULL; + } + else + elog(DEBUG3, "connection to %s already closed", entry->name); +} diff --git a/contrib/postgresql_fdw/postgresql_fdw.h b/contrib/postgresql_fdw/postgresql_fdw.h new file mode 100644 index 0000000..0af367c --- /dev/null +++ b/contrib/postgresql_fdw/postgresql_fdw.h @@ -0,0 +1,18 @@ +/* + * postgresql_fdw.h + * + * Foreign-data wrapper handler for PostgreSQL + * + * contrib/postgresql_fdw/postgresql_fdw.h + * Copyright (c) 2010, PostgreSQL Global Development Group + * ALL RIGHTS RESERVED; + * + */ + +#ifndef POSTGRESQL_FDW_H +#define POSTGRESQL_FDW_H + +/* Connection name used for unnamed connection */ +#define UNNAMED_CONN_NAME "unnamed" + +#endif /* POSTGRESQL_FDW_H */ diff --git a/contrib/postgresql_fdw/postgresql_fdw.sql.in b/contrib/postgresql_fdw/postgresql_fdw.sql.in new file mode 100644 index 0000000..93d5926 --- /dev/null +++ b/contrib/postgresql_fdw/postgresql_fdw.sql.in @@ -0,0 +1,14 @@ +/* contrib/postgresql/postgresql.sql.in */ + +-- Adjust this setting to control where the objects get created. +set search_path = public; + +CREATE OR REPLACE FUNCTION postgresql_fdw_handler () +RETURNS fdw_handler +AS 'MODULE_PATHNAME','postgresql_fdw_handler' +LANGUAGE C STRICT; + +CREATE FOREIGN DATA WRAPPER postgresql_fdw +VALIDATOR postgresql_fdw_validator +HANDLER postgresql_fdw_handler; + diff --git a/contrib/postgresql_fdw/sql/postgresql_fdw.sql b/contrib/postgresql_fdw/sql/postgresql_fdw.sql new file mode 100644 index 0000000..291c7b6 --- /dev/null +++ b/contrib/postgresql_fdw/sql/postgresql_fdw.sql @@ -0,0 +1,84 @@ +SET SEARCH_PATH = public; +SET DATESTYLE = 'Postgres, MDY'; + +-- ============================================================================= +-- Prepare section +-- ============================================================================= +-- connect database for regression test +\c contrib_regression + +-- install postgresql_fdw module +SET client_min_messages = warning; +\set ECHO none +\i postgresql_fdw.sql +\set ECHO all + +-- define fdw-related objects +CREATE SERVER loopback1 FOREIGN DATA WRAPPER postgresql_fdw + OPTIONS (dbname 'contrib_regression'); +CREATE SERVER loopback2 FOREIGN DATA WRAPPER postgresql_fdw + OPTIONS (dbname 'contrib_regression'); + +CREATE USER MAPPING FOR PUBLIC SERVER loopback1; +CREATE USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (user 'invalid'); + +CREATE TABLE t1( + c1 integer, + c2 text, + c3 date +); + +COPY t1 FROM stdin; +1 foo 1970-01-01 +2 bar 1970-01-02 +3 buz 1970-01-03 +\. + +CREATE TABLE t2( + c1 integer, + c2 text, + c3 date +); + +COPY t2 FROM stdin; +1 foo 1970-01-01 +12 bar 1970-01-02 +13 buz 1970-01-03 +\. + +CREATE FOREIGN TABLE ft1 ( + c1 integer OPTIONS (colname 'invalid'), + c2 text OPTIONS (colname 'C2'), + c3 date +) SERVER loopback1 OPTIONS (relname 't1'); +ALTER FOREIGN TABLE ft1 ALTER COLUMN c1 OPTIONS (SET colname 'C1'); +ALTER FOREIGN TABLE ft1 ALTER COLUMN c2 OPTIONS (DROP colname); + +CREATE FOREIGN TABLE ft2 ( + c1 integer, + c2 text, + c3 date +) SERVER loopback2 OPTIONS (relname 'invalid'); + +-- simple query and connection caching +SELECT ft1.* FROM ft1 ORDER BY c1; +SELECT * FROM ft2 ORDER BY c1; -- ERROR +ALTER USER MAPPING FOR PUBLIC SERVER loopback2 OPTIONS (DROP user); +SELECT * FROM ft2 ORDER BY c1; -- ERROR +ALTER FOREIGN TABLE ft2 OPTIONS (SET relname 't2'); +SELECT * FROM ft2 ORDER BY c1; + +-- join two foreign tables +SELECT * FROM ft1 JOIN ft2 ON (ft1.c1 = ft2.c1) ORDER BY ft1.c1; +-- join itself +SELECT * FROM ft1 t1 JOIN ft1 t2 ON (t1.c1 = t2.c1) ORDER BY t1.c1; +-- outer join +SELECT * FROM ft1 t1 LEFT JOIN ft2 t2 ON (t1.c1 = t2.c1) ORDER BY 1,2,3,4,5,6; +-- WHERE clause push-down +set client_min_messages = debug1; +SELECT * FROM ft1 WHERE c1 = 1 AND c2 = lower('FOO') AND c3 < now(); +reset client_min_messages; + +-- clean up +DROP FOREIGN DATA WRAPPER postgresql_fdw CASCADE; +DROP TABLE t1 CASCADE; diff --git a/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql b/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql new file mode 100644 index 0000000..a24bbd4 --- /dev/null +++ b/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql @@ -0,0 +1,7 @@ +/* contrib/postgresql_fdw/uninstall_postgresql_fdw.sql */ + +-- Adjust this setting to control where the objects get dropped. +set search_path = public; + +DROP FOREIGN DATA WRAPPER postgresql_fdw; +DROP FUNCTION postgresql_fdw_handler (); diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml index 75d08d5..d9bfc99 100644 --- a/doc/src/sgml/contrib.sgml +++ b/doc/src/sgml/contrib.sgml @@ -115,6 +115,7 @@ psql -d dbname -f SHAREDIR/contrib/module.sql &pgtestfsync; &pgtrgm; &pgupgrade; + &postgresql-fdw; &seg; &sepgsql; &contrib-spi; diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml index 659bcba..657e348 100644 --- a/doc/src/sgml/filelist.sgml +++ b/doc/src/sgml/filelist.sgml @@ -128,6 +128,7 @@ + diff --git a/doc/src/sgml/postgresql-fdw.sgml b/doc/src/sgml/postgresql-fdw.sgml new file mode 100644 index 0000000..139ea9b --- /dev/null +++ b/doc/src/sgml/postgresql-fdw.sgml @@ -0,0 +1,795 @@ + + + + postgresql_fdw + + + postgresql_fdw + + + + The postgresql_fdw module provides foreign-data wrapper + handler function postgresql_fdw_handler which can be + used to access external PostgreSQL server via plain SQL. + + + + Functions + + + + + postgresql_fdw_handler() returns fdw_handler + + + + + postgresql_fdw_handler is a foreign-data wrapper + handler function which returns foreign-data wrapper handler for + PostgreSQL in type of fdw_handler. + Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be + called from a SQL statement. + + + Internally, it returns a pointer to a FdwRoutine + object which has set of foreign-data wrapper API functions for handling + foreign scan on the external PostgreSQL server. Functions other than + Iterate can be NULL if the foreign-data wrapper has nothing to do in the + function. + + + + + + + + + + Details of postgresql_fdw + + + Connection options + + The postgresql_fdw retrieves connection information from generic options of + user mapping and foriegn server. All of generic options of these objects + are passed to PQconnectdbParams(). + + + Currently, all of the generic options which are allowed in the context of + user mapping and foreign server are libpq connection options. + + + + + Connection management + + The postgresql_fdw connects to a remote PostgreSQL server when + pgConnectServer() is called for the foreign server + first time in the local query. The connection is used by all of remote + queries which are executed on same remote PostgreSQL server. + If the local query uses multiple foreign PostgreSQL servers, connections + are established for each server (not for each foreign table) and all of + them will be closed at the end of the query. This also means that + connection pooling is not implemented in postgresql_fdw. + + + + + + + Transaction management + + The postgresql_fdw never emit transaction command such as BEGIN, + ROLLBACK and COMMIT. Thus, all SQL statements are + executed in each transaction when 'autocommit' was set to 'on'. + + + + + Retrieving all tuples at once + + The postgresql_fdw retrieves all of the result tuples at once via libpq + when the query was executed. Note that huge result set causes huge memory + consumption. The memory for the result set will be freed at the end of the + each query. + + + + + WHERE clause push-down + + The postgresql_fdw pushes some part of WHERE clause down to the remote + server, only if the evaluating the part of clause doesn't break the + consistency of the query. If a clause consist of elements below, the + clause will be pushed down. + + + push-down-able elements + + + + Element + Note + + + + + Constant value and column reference + + + + Array of push-down-able type + + + + Parameter of EXECUTE + + + + Bool expression such as A AND B or + A OR B + + + + Immutable operator + + + + DISTINCT operator, such as + A IS DISTINCT FROM B + + + + Scalar array operator, such as ALL(...) and + ANY(...) + + + + Immutable function call + + + + +
+ + + + + + + + + + postgresql_fdw + + + postgresql_fdw + + + + The postgresql_fdw module provides foreign-data wrapper + handler function postgresql_fdw_handler which can be + used to access external PostgreSQL server via plain SQL. + + + + Functions + + + + + postgresql_fdw_handler() returns fdw_handler + + + + + postgresql_fdw_handler is a foreign-data wrapper + handler function which returns foreign-data wrapper handler for + PostgreSQL in type of fdw_handler. + Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be + called from a SQL statement. + + + Internally, it returns a pointer to a FdwRoutine + object which has set of foreign-data wrapper API functions for handling + foreign scan on the external PostgreSQL server. Functions other than + Iterate can be NULL if the foreign-data wrapper has nothing to do in the + function. + + + + + + + + + + Details of postgresql_fdw + + + Connection options + + The postgresql_fdw retrieves connection information from generic options of + user mapping and foriegn server. All of generic options of these objects + are passed to PQconnectdbParams(). + + + Currently, all of the generic options which are allowed in the context of + user mapping and foreign server are libpq connection options. + + + + + Connection management + + The postgresql_fdw connects to a remote PostgreSQL server when + pgConnectServer() is called for the foreign server + first time in the local query. The connection is used by all of remote + queries which are executed on same remote PostgreSQL server. + If the local query uses multiple foreign PostgreSQL servers, connections + are established for each server (not for each foreign table) and all of + them will be closed at the end of the query. This also means that + connection pooling is not implemented in postgresql_fdw. + + + + + + + Transaction management + + The postgresql_fdw never emit transaction command such as BEGIN, + ROLLBACK and COMMIT. Thus, all SQL statements are + executed in each transaction when 'autocommit' was set to 'on'. + + + + + Retrieving all tuples at once + + The postgresql_fdw retrieves all of the result tuples at once via libpq + when the query was executed. Note that huge result set causes huge memory + consumption. The memory for the result set will be freed at the end of the + each query. + + + + + WHERE clause push-down + + The postgresql_fdw pushes some part of WHERE clause down to the remote + server, only if the evaluating the part of clause doesn't break the + consistency of the query. If a clause consist of elements below, the + clause will be pushed down. + + + push-down-able elements + + + + Element + Note + + + + + Constant value and column reference + + + + Array of push-down-able type + + + + Parameter of EXECUTE + + + + Bool expression such as A AND B or + A OR B + + + + Immutable operator + + + + DISTINCT operator, such as + A IS DISTINCT FROM B + + + + Scalar array operator, such as ALL(...) and + ANY(...) + + + + Immutable function call + + + + +
+ + + + + + + + + + postgresql_fdw + + + postgresql_fdw + + + + The postgresql_fdw module provides foreign-data wrapper + handler function postgresql_fdw_handler which can be + used to access external PostgreSQL server via plain SQL. + + + + Functions + + + + + postgresql_fdw_handler() returns fdw_handler + + + + + postgresql_fdw_handler is a foreign-data wrapper + handler function which returns foreign-data wrapper handler for + PostgreSQL in type of fdw_handler. + Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be + called from a SQL statement. + + + Internally, it returns a pointer to a FdwRoutine + object which has set of foreign-data wrapper API functions for handling + foreign scan on the external PostgreSQL server. Functions other than + Iterate can be NULL if the foreign-data wrapper has nothing to do in the + function. + + + + + + + + + + Details of postgresql_fdw + + + Connection options + + The postgresql_fdw retrieves connection information from generic options of + user mapping and foriegn server. All of generic options of these objects + are passed to PQconnectdbParams(). + + + Currently, all of the generic options which are allowed in the context of + user mapping and foreign server are libpq connection options. + + + + + Connection management + + The postgresql_fdw connects to a remote PostgreSQL server when + pgConnectServer() is called for the foreign server + first time in the local query. The connection is used by all of remote + queries which are executed on same remote PostgreSQL server. + If the local query uses multiple foreign PostgreSQL servers, connections + are established for each server (not for each foreign table) and all of + them will be closed at the end of the query. This also means that + connection pooling is not implemented in postgresql_fdw. + + + + + + + Transaction management + + The postgresql_fdw never emit transaction command such as BEGIN, + ROLLBACK and COMMIT. Thus, all SQL statements are + executed in each transaction when 'autocommit' was set to 'on'. + + + + + Retrieving all tuples at once + + The postgresql_fdw retrieves all of the result tuples at once via libpq + when the query was executed. Note that huge result set causes huge memory + consumption. The memory for the result set will be freed at the end of the + each query. + + + + + WHERE clause push-down + + The postgresql_fdw pushes some part of WHERE clause down to the remote + server, only if the evaluating the part of clause doesn't break the + consistency of the query. If a clause consist of elements below, the + clause will be pushed down. + + + push-down-able elements + + + + Element + Note + + + + + Constant value and column reference + + + + Array of push-down-able type + + + + Parameter of EXECUTE + + + + Bool expression such as A AND B or + A OR B + + + + Immutable operator + + + + DISTINCT operator, such as + A IS DISTINCT FROM B + + + + Scalar array operator, such as ALL(...) and + ANY(...) + + + + Immutable function call + + + + +
+ + + + + + + + + + postgresql_fdw + + + postgresql_fdw + + + + The postgresql_fdw module provides foreign-data wrapper + handler function postgresql_fdw_handler which can be + used to access external PostgreSQL server via plain SQL. + + + + Functions + + + + + postgresql_fdw_handler() returns fdw_handler + + + + + postgresql_fdw_handler is a foreign-data wrapper + handler function which returns foreign-data wrapper handler for + PostgreSQL in type of fdw_handler. + Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be + called from a SQL statement. + + + Internally, it returns a pointer to a FdwRoutine + object which has set of foreign-data wrapper API functions for handling + foreign scan on the external PostgreSQL server. Functions other than + Iterate can be NULL if the foreign-data wrapper has nothing to do in the + function. + + + + + + + + + + Details of postgresql_fdw + + + Connection options + + The postgresql_fdw retrieves connection information from generic options of + user mapping and foriegn server. All of generic options of these objects + are passed to PQconnectdbParams(). + + + Currently, all of the generic options which are allowed in the context of + user mapping and foreign server are libpq connection options. + + + + + Connection management + + The postgresql_fdw connects to a remote PostgreSQL server when + pgConnectServer() is called for the foreign server + first time in the local query. The connection is used by all of remote + queries which are executed on same remote PostgreSQL server. + If the local query uses multiple foreign PostgreSQL servers, connections + are established for each server (not for each foreign table) and all of + them will be closed at the end of the query. This also means that + connection pooling is not implemented in postgresql_fdw. + + + + + + + Transaction management + + The postgresql_fdw never emit transaction command such as BEGIN, + ROLLBACK and COMMIT. Thus, all SQL statements are + executed in each transaction when 'autocommit' was set to 'on'. + + + + + Retrieving all tuples at once + + The postgresql_fdw retrieves all of the result tuples at once via libpq + when the query was executed. Note that huge result set causes huge memory + consumption. The memory for the result set will be freed at the end of the + each query. + + + + + WHERE clause push-down + + The postgresql_fdw pushes some part of WHERE clause down to the remote + server, only if the evaluating the part of clause doesn't break the + consistency of the query. If a clause consist of elements below, the + clause will be pushed down. + + + push-down-able elements + + + + Element + Note + + + + + Constant value and column reference + + + + Array of push-down-able type + + + + Parameter of EXECUTE + + + + Bool expression such as A AND B or + A OR B + + + + Immutable operator + + + + DISTINCT operator, such as + A IS DISTINCT FROM B + + + + Scalar array operator, such as ALL(...) and + ANY(...) + + + + Immutable function call + + + + +
+ + + + + + + + + + postgresql_fdw + + + postgresql_fdw + + + + The postgresql_fdw module provides foreign-data wrapper + handler function postgresql_fdw_handler which can be + used to access external PostgreSQL server via plain SQL. + + + + Functions + + + + + postgresql_fdw_handler() returns fdw_handler + + + + + postgresql_fdw_handler is a foreign-data wrapper + handler function which returns foreign-data wrapper handler for + PostgreSQL in type of fdw_handler. + Since fdw_hanlder is a pseudo type, postgresql_fdw_handler can't be + called from a SQL statement. + + + Internally, it returns a pointer to a FdwRoutine + object which has set of foreign-data wrapper API functions for handling + foreign scan on the external PostgreSQL server. Functions other than + Iterate can be NULL if the foreign-data wrapper has nothing to do in the + function. + + + + + + + + + + Details of postgresql_fdw + + + Connection options + + The postgresql_fdw retrieves connection information from generic options of + user mapping and foriegn server. All of generic options of these objects + are passed to PQconnectdbParams(). + + + Currently, all of the generic options which are allowed in the context of + user mapping and foreign server are libpq connection options. + + + + + Connection management + + The postgresql_fdw connects to a remote PostgreSQL server when + pgConnectServer() is called for the foreign server + first time in the local query. The connection is used by all of remote + queries which are executed on same remote PostgreSQL server. + If the local query uses multiple foreign PostgreSQL servers, connections + are established for each server (not for each foreign table) and all of + them will be closed at the end of the query. This also means that + connection pooling is not implemented in postgresql_fdw. + + + + + + + Transaction management + + The postgresql_fdw never emit transaction command such as BEGIN, + ROLLBACK and COMMIT. Thus, all SQL statements are + executed in each transaction when 'autocommit' was set to 'on'. + + + + + Retrieving all tuples at once + + The postgresql_fdw retrieves all of the result tuples at once via libpq + when the query was executed. Note that huge result set causes huge memory + consumption. The memory for the result set will be freed at the end of the + each query. + + + + + WHERE clause push-down + + The postgresql_fdw pushes some part of WHERE clause down to the remote + server, only if the evaluating the part of clause doesn't break the + consistency of the query. If a clause consist of elements below, the + clause will be pushed down. + + + push-down-able elements + + + + Element + Note + + + + + Constant value and column reference + + + + Array of push-down-able type + + + + Parameter of EXECUTE + + + + Bool expression such as A AND B or + A OR B + + + + Immutable operator + + + + DISTINCT operator, such as + A IS DISTINCT FROM B + + + + Scalar array operator, such as ALL(...) and + ANY(...) + + + + Immutable function call + + + + +
+ + + + + + diff --git a/src/backend/foreign/foreign.c b/src/backend/foreign/foreign.c index 8089fc6..65e0c32 100644 --- a/src/backend/foreign/foreign.c +++ b/src/backend/foreign/foreign.c @@ -433,55 +433,82 @@ pg_options_to_table(PG_FUNCTION_ARGS) /* * Describes the valid options for postgresql FDW, server, and user mapping. */ -struct ConnectionOption +struct PgFdwOption { const char *optname; Oid optcontext; /* Oid of catalog in which option may appear */ + bool is_conn_opt; /* True if the option is a connection option */ }; /* - * Copied from fe-connect.c PQconninfoOptions. - * + * Valid options for postgresql_fdw. + * Connection options are copied from fe-connect.c PQconninfoOptions. * The list is small - don't bother with bsearch if it stays so. */ -static struct ConnectionOption libpq_conninfo_options[] = { - {"authtype", ForeignServerRelationId}, - {"service", ForeignServerRelationId}, - {"user", UserMappingRelationId}, - {"password", UserMappingRelationId}, - {"connect_timeout", ForeignServerRelationId}, - {"dbname", ForeignServerRelationId}, - {"host", ForeignServerRelationId}, - {"hostaddr", ForeignServerRelationId}, - {"port", ForeignServerRelationId}, - {"tty", ForeignServerRelationId}, - {"options", ForeignServerRelationId}, - {"requiressl", ForeignServerRelationId}, - {"sslmode", ForeignServerRelationId}, - {"gsslib", ForeignServerRelationId}, - {NULL, InvalidOid} +static struct PgFdwOption valid_options[] = { + /* Connection Options */ + {"authtype", ForeignServerRelationId, true}, + {"service", ForeignServerRelationId, true}, + {"user", UserMappingRelationId, true}, + {"password", UserMappingRelationId, true}, + {"connect_timeout", ForeignServerRelationId, true}, + {"dbname", ForeignServerRelationId, true}, + {"host", ForeignServerRelationId, true}, + {"hostaddr", ForeignServerRelationId, true}, + {"port", ForeignServerRelationId, true}, + {"tty", ForeignServerRelationId, true}, + {"options", ForeignServerRelationId, true}, + {"requiressl", ForeignServerRelationId, true}, + {"sslmode", ForeignServerRelationId, true}, + {"gsslib", ForeignServerRelationId, true}, + + /* Catalog options */ + {"nspname", ForeignTableRelationId, false}, + {"relname", ForeignTableRelationId, false}, + {"colname", AttributeRelationId, false}, + + /* Planner cost options */ + {"connection_cost", ForeignServerRelationId, false}, + {"transfer_cost", ForeignServerRelationId, false}, + + /* Centinel */ + {NULL, InvalidOid, false} }; - /* - * Check if the provided option is one of libpq conninfo options. + * Check if the provided option is one of valid options. * context is the Oid of the catalog the option came from, or 0 if we * don't care. */ static bool -is_conninfo_option(const char *option, Oid context) +is_valid_option(const char *option, Oid context) { - struct ConnectionOption *opt; + struct PgFdwOption *opt; - for (opt = libpq_conninfo_options; opt->optname; opt++) + for (opt = valid_options; opt->optname; opt++) if (context == opt->optcontext && strcmp(opt->optname, option) == 0) return true; return false; } +/* + * Check if the provided option is one of libpq conninfo options. + * XXX: Should be moved to interface/libpq or backend/libpq? + */ +bool +is_libpq_connection_option(const char *option) +{ + struct PgFdwOption *opt; + + for (opt = valid_options; opt->optname; opt++) + if (opt->is_conn_opt && strcmp(opt->optname, option) == 0) + return true; + return false; +} /* - * Validate the generic option given to SERVER or USER MAPPING. + * Validate the generic option given to FOREIGN DATA WRAPPER, SERVER, USER + * MAPPING or FOREIGN TABLE. * Raise an ERROR if the option or its value is considered * invalid. * @@ -500,9 +527,9 @@ postgresql_fdw_validator(PG_FUNCTION_ARGS) { DefElem *def = lfirst(cell); - if (!is_conninfo_option(def->defname, catalog)) + if (!is_valid_option(def->defname, catalog)) { - struct ConnectionOption *opt; + struct PgFdwOption *opt; StringInfoData buf; /* @@ -510,7 +537,7 @@ postgresql_fdw_validator(PG_FUNCTION_ARGS) * with list of valid options for the object. */ initStringInfo(&buf); - for (opt = libpq_conninfo_options; opt->optname; opt++) + for (opt = valid_options; opt->optname; opt++) if (catalog == opt->optcontext) appendStringInfo(&buf, "%s%s", (buf.len > 0) ? ", " : "", opt->optname); diff --git a/src/include/foreign/foreign.h b/src/include/foreign/foreign.h index b0cb37c..e2ef32c 100644 --- a/src/include/foreign/foreign.h +++ b/src/include/foreign/foreign.h @@ -80,4 +80,6 @@ extern ForeignTable *GetForeignTable(Oid relid); extern FdwRoutine *GetFdwRoutineByRelId(Oid relid); extern FdwRoutine *GetFdwRoutine(Oid fdwhandler); +extern bool is_libpq_connection_option(const char *option); + #endif /* FOREIGN_H */ diff --git a/src/test/regress/expected/foreign_data.out b/src/test/regress/expected/foreign_data.out index 8f7eac5..9e4f3e0 100644 --- a/src/test/regress/expected/foreign_data.out +++ b/src/test/regress/expected/foreign_data.out @@ -284,7 +284,7 @@ CREATE SERVER s6 VERSION '16.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbna CREATE SERVER s7 TYPE 'oracle' VERSION '17.0' FOREIGN DATA WRAPPER foo OPTIONS (host 'a', dbname 'b'); CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (foo '1'); -- ERROR ERROR: invalid option "foo" -HINT: Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib +HINT: Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib, connection_cost, transfer_cost CREATE SERVER s8 FOREIGN DATA WRAPPER postgresql OPTIONS (host 'localhost', dbname 's8db'); \des+ List of foreign servers @@ -395,7 +395,7 @@ ERROR: permission denied for foreign-data wrapper foo RESET ROLE; ALTER SERVER s8 OPTIONS (foo '1'); -- ERROR option validation ERROR: invalid option "foo" -HINT: Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib +HINT: Valid options in this context are: authtype, service, connect_timeout, dbname, host, hostaddr, port, tty, options, requiressl, sslmode, gsslib, connection_cost, transfer_cost ALTER SERVER s8 OPTIONS (connect_timeout '30', SET dbname 'db1', DROP host); SET ROLE regress_test_role; ALTER SERVER s1 OWNER TO regress_test_indirect; -- ERROR