diff --git a/contrib/postgresql_fdw/postgresql_fdw.c b/contrib/postgresql_fdw/postgresql_fdw.c index cd7902d..17e3856 100644 --- a/contrib/postgresql_fdw/postgresql_fdw.c +++ b/contrib/postgresql_fdw/postgresql_fdw.c @@ -3,17 +3,19 @@ * postgresql_fdw.c * foreign-data wrapper for PostgreSQL * - * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group + * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group * * IDENTIFICATION - * $PostgreSQL$ + * 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" @@ -40,25 +42,21 @@ extern Datum postgresql_fdw_handler(PG_FUNCTION_ARGS); /* * FDW routines */ -static FSConnection* pgConnectServer(ForeignServer *server, UserMapping *user); -static void pgFreeFSConnection(FSConnection *conn); -static void pgEstimateCosts(ForeignPath *path, PlannerInfo *root, RelOptInfo *baserel); -static void pgOpen(ForeignScanState *scanstate); -static void pgBeginScan(ForeignScanState *scanstate); -static void pgIterate(ForeignScanState *scanstate); -static void pgClose(ForeignScanState *scanstate); -static void pgReOpen(ForeignScanState *scanstate); +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(Expr *expr); + +static bool is_foreign_qual(PlannerInfo *root, RelOptInfo *baserel, Expr *expr); static bool foreign_qual_walker(Node *node, void *context); static void deparseSelectClause(StringInfo sql, ForeignTable *table, TupleDesc tupdesc, const char *aliasname, bool prefix); -static void deparseFromClause(StringInfo sql, ForeignTable *table, const char *aliasname, bool prefix); -static char *deparseSql(ForeignScanState *scanstate); +static char *deparseSql(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel); -/* helper for handling result tuples */ -static void storeResult(Tuplestorestate *tupstore, bool is_sql_cmd, - TupleDesc tupdesc, PGresult *res); +static void storeResult(TupleTableSlot *slot, PGresult *res, int rowno); /* * Connection management @@ -75,25 +73,23 @@ static void cleanup_connection(ResourceReleasePhase phase, /* * PostgreSQL specific portion of a foreign query request */ -typedef struct pgFdwReply +typedef struct pgFdwExecutionState { - char *sql; /* SQL text to be sent to foreign server */ - Tuplestorestate *tupstore; /* store all of result tuples */ -} pgFdwReply; + PGconn *conn; + PGresult *res; + int nextrow; +} pgFdwExecutionState; /* * FdwRoutine of PostgreSQL wrapper */ static FdwRoutine postgresql_fdw_routine = { - pgConnectServer, - pgFreeFSConnection, - pgEstimateCosts, - pgOpen, + pgPlanRelScan, pgBeginScan, pgIterate, - pgClose, - pgReOpen, + pgReScan, + pgEndScan }; /* @@ -107,58 +103,18 @@ postgresql_fdw_handler(PG_FUNCTION_ARGS) PG_RETURN_POINTER(&postgresql_fdw_routine); } -/* - * Connect to a foreign PostgreSQL server with libpq if necessary. - */ -static FSConnection * -pgConnectServer(ForeignServer *server, UserMapping *user) +static FdwPlan * +pgPlanRelScan(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel) { - elog(DEBUG3, "%s() called for \"%s\"", __FUNCTION__, server->servername); - - return (FSConnection *) GetConnection(server, user); -} + FdwPlan *plan = makeNode(FdwPlan); + char *sql; + sql = deparseSql(foreigntableid, root, baserel); -/* - * Disconnect from the foreign server if the connection is not referenced by - * any other scan. - */ -static void -pgFreeFSConnection(FSConnection *conn) -{ - elog(DEBUG3, "%s() called", __FUNCTION__); - - if (conn == NULL) - return; - - ReleaseConnection((PGconn *)conn); -} + plan->explainInfo = sql; + plan->fdw_private = (void *) sql; -/* - * 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(Expr *expr) -{ - return !foreign_qual_walker((Node *) expr, NULL); + return plan; } /* @@ -237,8 +193,10 @@ deparseSelectClause(StringInfo sql, ForeignTable *table, TupleDesc tupdesc, first = true; for (i = 0; i < tupdesc->natts; i++) { +#ifdef NOT_USED List *options; ListCell *lc; +#endif char *colname = NULL; /* skip dropped attributes */ @@ -246,6 +204,7 @@ deparseSelectClause(StringInfo sql, ForeignTable *table, TupleDesc tupdesc, continue; /* Determine column name to be used */ +#ifdef NOT_USED /* XXX: What was this all about? */ options = GetGenericOptionsPerColumn(table->relid, i + 1); foreach (lc, options) { @@ -256,6 +215,7 @@ deparseSelectClause(StringInfo sql, ForeignTable *table, TupleDesc tupdesc, break; } } +#endif if (!colname) colname = tupdesc->attrs[i]->attname.data; @@ -278,51 +238,141 @@ deparseSelectClause(StringInfo sql, ForeignTable *table, TupleDesc tupdesc, pfree((char *) aliasname_q); } -/* - * Deparse the passed information into FROM clauses and append to the buffer - * 'sql'. - */ static void -deparseFromClause(StringInfo sql, ForeignTable *table, const char *aliasname, bool prefix) +deparse_var(PlannerInfo *root, StringInfo buf, Var *var) { - char *nspname = NULL; - char *relname = NULL; - const char *nspname_q; - const char *relname_q; - const char *aliasname_q; - ListCell *lc; + RangeTblEntry *rte; + char *attname; - /* The alias of relation is used in both SELECT clause and FROM clause. */ - aliasname_q = quote_identifier(aliasname); + if (var->varlevelsup != 0) + elog(ERROR, "unexpected varlevelsup %d in remote query", + var->varlevelsup); - /* - * If the foreign table has generic option "nspname" and/or "relname", use - * them in the foreign query. Otherwise, use local catalog names. - * Each identifier should be quoted because they might be case sensitive. - */ - foreach(lc, table->options) + if (var->varno < 1 || var->varno > list_length(root->parse->rtable)) + elog(ERROR, "unexpected varno %d in remote query", var->varno); + rte = rt_fetch(var->varno, root->parse->rtable); + + attname = get_rte_attribute_name(rte, var->varattno); + appendStringInfoString(buf, quote_identifier(attname)); +} + +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)) { - 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)); + 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; } - if (nspname == NULL) - nspname = get_namespace_name(get_rel_namespace(table->relid)); - if (relname == NULL) - relname = get_rel_name(table->relid); - nspname_q = quote_identifier(nspname); - relname_q = quote_identifier(relname); - appendStringInfo(sql, " FROM %s.%s %s", nspname_q, relname_q, aliasname_q); - pfree(nspname); - pfree(relname); - if (nspname_q != nspname) - pfree((char *) nspname_q); - if (relname_q != relname) - pfree((char * ) relname_q); - if (aliasname_q != aliasname) - pfree((char *) aliasname_q); + + return expression_tree_walker(node, foreign_qual_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; } /* @@ -336,39 +386,58 @@ deparseFromClause(StringInfo sql, ForeignTable *table, const char *aliasname, bo * remote side and local side */ static char * -deparseSql(ForeignScanState *scanstate) +deparseSql(Oid foreigntableid, PlannerInfo *root, RelOptInfo *baserel) { - EState *estate = scanstate->ss.ps.state; - bool prefix; List *context; StringInfoData sql; - ForeignScan *scan; - RangeTblEntry *rte; - ForeignTable *table = scanstate->table; + ForeignTable *table = GetForeignTable(foreigntableid); + ListCell *lc; + bool first; + char *nspname = NULL; + char *relname = NULL; /* extract ForeignScan and RangeTblEntry */ - scan = (ForeignScan *)scanstate->ss.ps.plan; - rte = list_nth(estate->es_range_table, scan->scan.scanrelid - 1); /* prepare to deparse plan */ initStringInfo(&sql); - context = deparse_context_for_planstate((Node *)&scanstate->ss.ps, NULL, - estate->es_range_table); + + context = deparse_context_for("foreigntable", foreigntableid); + + /* deparse SELECT target list */ + appendStringInfoString(&sql, "SELECT "); + first = true; + foreach (lc, baserel->reltargetlist) + { + Var *var = lfirst(lc); + + if (!first) + appendStringInfoString(&sql, ", "); + first = false; + deparse_var(root, &sql, var); + } /* - * XXX: Prefix is set to false always because setting prefix to true makes - * the SQL invalid when this is a child scan for an inherited table and qual - * is not empty (need to generate WHERE clause). It might be needed to fix - * deparse_expression() to deparse column references in the qual into - * name of the child table, instead of name of the parent table, or table - * alias. + * Deparse FROM + * + * If the foreign table has generic option "nspname" and/or "relname", use + * them in the foreign query. Otherwise, use local catalog names. */ - prefix = false; - - /* deparse SELECT and FROM clauses */ - deparseSelectClause(&sql, table, scanstate->ss.ss_currentRelation->rd_att, - rte->eref->aliasname, prefix); - deparseFromClause(&sql, table, rte->eref->aliasname, prefix); + 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 @@ -381,10 +450,9 @@ deparseSql(ForeignScanState *scanstate) * statement to make following EXECUTE statements work properly. The Plan * node is used repeatedly to create PlanState for each EXECUTE statement. */ - if (scanstate->ss.ps.plan->qual) + if (baserel->baserestrictinfo) { List *local_qual = NIL; - List *foreign_qual = NIL; List *foreign_expr = NIL; ListCell *lc; @@ -392,23 +460,24 @@ deparseSql(ForeignScanState *scanstate) * Divide qual of PlanState into two lists, one for local evaluation * and one for foreign evaluation. */ - foreach (lc, scanstate->ss.ps.qual) + foreach (lc, baserel->baserestrictinfo) { - ExprState *state = lfirst(lc); + RestrictInfo *ri = (RestrictInfo *) lfirst(lc); - if (is_foreign_qual(state->expr)) - { foreign_qual = lappend(foreign_qual, state); - foreign_expr = lappend(foreign_expr, state->expr); + 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, state); + 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. */ - scanstate->ss.ps.qual = local_qual; + baserel->baserestrictinfo = local_qual; /* * Deparse quals to be evaluated in the foreign server if any. @@ -420,7 +489,7 @@ deparseSql(ForeignScanState *scanstate) Node *node; node = (Node *) make_ands_explicit(foreign_expr); appendStringInfo(&sql, " WHERE %s", - deparse_expression(node, context, prefix, false)); + deparse_expression(node, context, false, false)); /* * The contents of the list MUST NOT be free-ed because they are * referenced from Plan.qual list. @@ -435,39 +504,29 @@ deparseSql(ForeignScanState *scanstate) } /* - * Deparse the request into SQL statement and keep it for future execution. - * - * XXX: deparsing should be done in pgEstimateCosts to estimate the costs by - * executing EXPLAIN on remote side? - */ -static void -pgOpen(ForeignScanState *scanstate) -{ - pgFdwReply *reply; - - elog(DEBUG3, "%s() called ", __FUNCTION__); - - /* FWD-specific portion */ - reply = (pgFdwReply *) palloc0(sizeof(*reply)); - reply->sql = deparseSql(scanstate); - scanstate->reply = (FdwReply *) reply; -} - -/* * 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 void -pgBeginScan(ForeignScanState *scanstate) +static FdwExecutionState * +pgBeginScan(FdwPlan *plan, ParamListInfo params) { - pgFdwReply *reply = (pgFdwReply *) scanstate->reply; - PGconn *conn = (PGconn *) scanstate->conn; - PGresult *res; - ParamListInfo info = scanstate->ss.ps.state->es_param_list_info; - int numParams = info ? info->numParams : 0; - Oid *types = NULL; - const char **values = NULL; + 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 = (const char *) plan->fdw_private; + + state = palloc(sizeof(pgFdwExecutionState)); + + conn = GetConnection(GetForeignServer(plan->serverid), + GetUserMapping(plan->userid, plan->serverid)); + state->conn = conn; + + result->fdw_private = state; elog(DEBUG3, "%s() called", __FUNCTION__); @@ -481,8 +540,8 @@ pgBeginScan(ForeignScanState *scanstate) values = palloc0(sizeof(char *) * numParams); for (i = 0; i < numParams; i++) { - types[i] = info->params[i].ptype; - if (info->params[i].isnull) + types[i] = params->params[i].ptype; + if (params->params[i].isnull) values[i] = NULL; else { @@ -495,7 +554,7 @@ pgBeginScan(ForeignScanState *scanstate) getTypeOutputInfo(types[i], &out_func_oid, &isvarlena); fmgr_info(out_func_oid, &func); values[i] = - OutputFunctionCall(&func, info->params[i].value); + OutputFunctionCall(&func, params->params[i].value); } } } @@ -505,8 +564,7 @@ pgBeginScan(ForeignScanState *scanstate) * TODO: support internal parameters(PARAM_EXTERN) * TODO: support cursor mode for huge result sets. */ - res = PQexecParams(conn, reply->sql, - numParams, types, values, NULL, NULL, 0); + res = PQexecParams(conn, sql, numParams, types, values, NULL, NULL, 0); if (numParams > 0) { int i; @@ -525,31 +583,18 @@ pgBeginScan(ForeignScanState *scanstate) { char *msg; - PQclear(res); msg = pstrdup(PQerrorMessage(conn)); - ereport(ERROR, ( - errmsg("could not execute foreign query"), - errdetail("%s", msg), errhint("%s", reply->sql))); + PQclear(res); + ereport(ERROR, + (errmsg("could not execute foreign query"), + errdetail("%s", msg), + errhint("%s", sql))); } - /* Note: use PG_TRY to ensure freeing PGresult. */ - PG_TRY(); - { - TupleDesc tupdesc = ExecGetScanType((ScanState *) scanstate); - - /* create tuplestore to store results */ - reply->tupstore = tuplestore_begin_heap(true, false, work_mem); + state->res = res; + state->nextrow = 0; - storeResult(reply->tupstore, false, tupdesc, res); - - PQclear(res); - } - PG_CATCH(); - { - PQclear(res); - PG_RE_THROW(); - } - PG_END_TRY(); + return result; } /* @@ -562,87 +607,48 @@ pgBeginScan(ForeignScanState *scanstate) * ScanState. */ static void -pgIterate(ForeignScanState *scanstate) +pgIterate(FdwExecutionState *state, TupleTableSlot *slot) { - pgFdwReply *reply = (pgFdwReply *) scanstate->reply; - TupleTableSlot *slot = scanstate->ss.ss_ScanTupleSlot; + pgFdwExecutionState *priv = state->fdw_private; elog(DEBUG3, "%s() called", __FUNCTION__); - /* store the next tuple into the slot from the tuplestore */ - if (tuplestore_gettupleslot(reply->tupstore, true, false, slot)) - { - /* - * Because the tuples stored in the tupstore are minimal tuples, - * they have to be materialized to retrieve system attributes. - */ - ExecMaterializeSlot(slot); - } + if (priv->nextrow == PQntuples(priv->res)) + ExecClearTuple(slot); else - { - /* TODO: if cursor mode, reset tuple slot and fetch the next batch. */ - } + storeResult(slot, priv->res, priv->nextrow++); } -/* - * Finish scanning foreign table and dispose objects used for this scan. - */ static void -pgClose(ForeignScanState *scanstate) +pgReScan(FdwExecutionState *state) { - pgFdwReply *reply = (pgFdwReply *) scanstate->reply; - - elog(DEBUG3, "%s() called", __FUNCTION__); - - if (reply == NULL) - return; - - if (reply->tupstore != NULL) - tuplestore_end(reply->tupstore); - - /* - * reply->conn is not freed here because foreign connections are - * released by executor via FreeFSConnection. - */ - pfree(reply); - scanstate->reply = NULL; + ((pgFdwExecutionState *)state->fdw_private)->nextrow = 0; } -/* - * Execute query with new parameter. - */ static void -pgReOpen(ForeignScanState *scanstate) +pgEndScan(FdwExecutionState *state) { - pgFdwReply *reply = (pgFdwReply *) scanstate->reply; + pgFdwExecutionState *priv = (pgFdwExecutionState *) state->fdw_private; - elog(DEBUG3, "%s() called", __FUNCTION__); - - /* Rewind tuplestore to retrieve all tuples again */ - if (reply->tupstore) - tuplestore_rescan(reply->tupstore); + PQclear(priv->res); + pfree(priv); } /* * Store a PGresult into tuplestore. */ static void -storeResult(Tuplestorestate *tupstore, - bool is_sql_cmd, - TupleDesc tupdesc, - PGresult *res) +storeResult(TupleTableSlot *slot, PGresult *res, int rowno) { int i; - int row; - int ntuples; int nfields; int attnum; /* number of non-dropped columns */ char **values; AttInMetadata *attinmeta; Form_pg_attribute *attrs; + TupleDesc tupdesc = slot->tts_tupleDescriptor; - ntuples = PQntuples(res); - nfields = is_sql_cmd ? 1 : PQnfields(res); + nfields = PQnfields(res); attrs = tupdesc->attrs; /* count non-dropped columns */ @@ -662,39 +668,29 @@ storeResult(Tuplestorestate *tupstore, /* put all tuples into the tuplestore */ attinmeta = TupleDescGetAttInMetadata(tupdesc); - for (row = 0; row < ntuples; row++) { int j; HeapTuple tuple; - CHECK_FOR_INTERRUPTS(); - - if (!is_sql_cmd) + for (i = 0, j = 0; i < tupdesc->natts; i++) { - for (i = 0, j = 0; i < tupdesc->natts; i++) + /* skip dropped columns. */ + if (attrs[i]->attisdropped) { - /* skip dropped columns. */ - if (attrs[i]->attisdropped) - { - values[i] = NULL; - continue; - } - - if (PQgetisnull(res, row, j)) - values[i] = NULL; - else - values[i] = PQgetvalue(res, row, j); - j++; + values[i] = NULL; + continue; } - } - else - { - values[0] = PQcmdStatus(res); + + if (PQgetisnull(res, rowno, j)) + values[i] = NULL; + else + values[i] = PQgetvalue(res, rowno, j); + j++; } /* build the tuple and put it into the tuplestore. */ tuple = BuildTupleFromCStrings(attinmeta, values); - tuplestore_puttuple(tupstore, tuple); + ExecStoreTuple(tuple, slot, InvalidBuffer, true); } /* clean up and return the tuplestore */ @@ -702,6 +698,7 @@ storeResult(Tuplestorestate *tupstore, pfree(values); } +#ifdef NOT_USED /* * Retrieve cost-factors of the foreign server from catalog. */ @@ -740,7 +737,7 @@ get_server_costs(Oid relid, double *connection_cost, double *transfer_cost) pfree(keywords); pfree(values); } - +#endif /* * Estimate costs of scanning on a foreign table. @@ -763,7 +760,12 @@ pgEstimateCosts(ForeignPath *path, PlannerInfo *root, RelOptInfo *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 * @@ -904,6 +906,23 @@ check_conn_params(const char **keywords, const char **values) 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) { diff --git a/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql b/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql index af39f54..a24bbd4 100644 --- a/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql +++ b/contrib/postgresql_fdw/uninstall_postgresql_fdw.sql @@ -1,4 +1,4 @@ -/* contrib/postgresql_fdw/uninstall_postgresql_fdw.sql.in */ +/* contrib/postgresql_fdw/uninstall_postgresql_fdw.sql */ -- Adjust this setting to control where the objects get dropped. set search_path = public;