postgres_fdw.h File Reference

#include "foreign/foreign.h"
#include "lib/stringinfo.h"
#include "libpq-fe.h"
#include "nodes/execnodes.h"
#include "nodes/pathnodes.h"
#include "utils/relcache.h"

Include dependency graph for postgres_fdw.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	PgFdwRelationInfo
struct	PgFdwConnState

Typedefs
typedef struct PgFdwRelationInfo	PgFdwRelationInfo
typedef struct PgFdwConnState	PgFdwConnState
typedef enum PgFdwSamplingMethod	PgFdwSamplingMethod

Enumerations
enum	PgFdwSamplingMethod {   ANALYZE_SAMPLE_OFF , ANALYZE_SAMPLE_AUTO , ANALYZE_SAMPLE_RANDOM , ANALYZE_SAMPLE_SYSTEM ,   ANALYZE_SAMPLE_BERNOULLI }

Functions
int	set_transmission_modes (void)
void	reset_transmission_modes (int nestlevel)
void	process_pending_request (AsyncRequest *areq)
PGconn *	GetConnection (UserMapping *user, bool will_prep_stmt, PgFdwConnState **state)
void	ReleaseConnection (PGconn *conn)
unsigned int	GetCursorNumber (PGconn *conn)
unsigned int	GetPrepStmtNumber (PGconn *conn)
void	do_sql_command (PGconn *conn, const char *sql)
PGresult *	pgfdw_get_result (PGconn *conn)
PGresult *	pgfdw_exec_query (PGconn *conn, const char *query, PgFdwConnState *state)
void	pgfdw_report_error (int elevel, PGresult *res, PGconn *conn, bool clear, const char *sql)
int	ExtractConnectionOptions (List *defelems, const char **keywords, const char **values)
List *	ExtractExtensionList (const char *extensionsString, bool warnOnMissing)
char *	process_pgfdw_appname (const char *appname)
void	classifyConditions (PlannerInfo *root, RelOptInfo *baserel, List *input_conds, List **remote_conds, List **local_conds)
bool	is_foreign_expr (PlannerInfo *root, RelOptInfo *baserel, Expr *expr)
bool	is_foreign_param (PlannerInfo *root, RelOptInfo *baserel, Expr *expr)
bool	is_foreign_pathkey (PlannerInfo *root, RelOptInfo *baserel, PathKey *pathkey)
void	deparseInsertSql (StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, List *targetAttrs, bool doNothing, List *withCheckOptionList, List *returningList, List **retrieved_attrs, int *values_end_len)
void	rebuildInsertSql (StringInfo buf, Relation rel, char *orig_query, List *target_attrs, int values_end_len, int num_params, int num_rows)
void	deparseUpdateSql (StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, List *targetAttrs, List *withCheckOptionList, List *returningList, List **retrieved_attrs)
void	deparseDirectUpdateSql (StringInfo buf, PlannerInfo *root, Index rtindex, Relation rel, RelOptInfo *foreignrel, List *targetlist, List *targetAttrs, List *remote_conds, List **params_list, List *returningList, List **retrieved_attrs)
void	deparseDeleteSql (StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, List *returningList, List **retrieved_attrs)
void	deparseDirectDeleteSql (StringInfo buf, PlannerInfo *root, Index rtindex, Relation rel, RelOptInfo *foreignrel, List *remote_conds, List **params_list, List *returningList, List **retrieved_attrs)
void	deparseAnalyzeSizeSql (StringInfo buf, Relation rel)
void	deparseAnalyzeInfoSql (StringInfo buf, Relation rel)
void	deparseAnalyzeSql (StringInfo buf, Relation rel, PgFdwSamplingMethod sample_method, double sample_frac, List **retrieved_attrs)
void	deparseTruncateSql (StringInfo buf, List *rels, DropBehavior behavior, bool restart_seqs)
void	deparseStringLiteral (StringInfo buf, const char *val)
EquivalenceMember *	find_em_for_rel (PlannerInfo *root, EquivalenceClass *ec, RelOptInfo *rel)
EquivalenceMember *	find_em_for_rel_target (PlannerInfo *root, EquivalenceClass *ec, RelOptInfo *rel)
List *	build_tlist_to_deparse (RelOptInfo *foreignrel)
void	deparseSelectStmtForRel (StringInfo buf, PlannerInfo *root, RelOptInfo *rel, List *tlist, List *remote_conds, List *pathkeys, bool has_final_sort, bool has_limit, bool is_subquery, List **retrieved_attrs, List **params_list)
const char *	get_jointype_name (JoinType jointype)
bool	is_builtin (Oid objectId)
bool	is_shippable (Oid objectId, Oid classId, PgFdwRelationInfo *fpinfo)

Variables
char *	pgfdw_application_name

Typedef Documentation

PgFdwConnState

typedef struct PgFdwConnState PgFdwConnState

PgFdwRelationInfo

typedef struct PgFdwRelationInfo PgFdwRelationInfo

PgFdwSamplingMethod

typedef enum PgFdwSamplingMethod PgFdwSamplingMethod

Enumeration Type Documentation

PgFdwSamplingMethod

enum PgFdwSamplingMethod

Enumerator
ANALYZE_SAMPLE_OFF
ANALYZE_SAMPLE_AUTO
ANALYZE_SAMPLE_RANDOM
ANALYZE_SAMPLE_SYSTEM
ANALYZE_SAMPLE_BERNOULLI

Definition at line 144 of file postgres_fdw.h.

{
    ANALYZE_SAMPLE_OFF,         /* no remote sampling */
    ANALYZE_SAMPLE_AUTO,        /* choose by server version */
    ANALYZE_SAMPLE_RANDOM,      /* remote random() */
    ANALYZE_SAMPLE_SYSTEM,      /* TABLESAMPLE system */
    ANALYZE_SAMPLE_BERNOULLI,   /* TABLESAMPLE bernoulli */
} PgFdwSamplingMethod;

Function Documentation

build_tlist_to_deparse()

List* build_tlist_to_deparse

(

RelOptInfo *

foreignrel

)

Definition at line 1176 of file deparse.c.

{
    List       *tlist = NIL;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
    ListCell   *lc;
 
    /*
     * For an upper relation, we have already built the target list while
     * checking shippability, so just return that.
     */
    if (IS_UPPER_REL(foreignrel))
        return fpinfo->grouped_tlist;
 
    /*
     * We require columns specified in foreignrel->reltarget->exprs and those
     * required for evaluating the local conditions.
     */
    tlist = add_to_flat_tlist(tlist,
                              pull_var_clause((Node *) foreignrel->reltarget->exprs,
                                              PVC_RECURSE_PLACEHOLDERS));
    foreach(lc, fpinfo->local_conds)
    {
        RestrictInfo *rinfo = lfirst_node(RestrictInfo, lc);
 
        tlist = add_to_flat_tlist(tlist,
                                  pull_var_clause((Node *) rinfo->clause,
                                                  PVC_RECURSE_PLACEHOLDERS));
    }
 
    return tlist;
}

References add_to_flat_tlist(), RestrictInfo::clause, PathTarget::exprs, PgFdwRelationInfo::grouped_tlist, if(), IS_UPPER_REL, lfirst_node, PgFdwRelationInfo::local_conds, NIL, pull_var_clause(), PVC_RECURSE_PLACEHOLDERS, and RelOptInfo::reltarget.

Referenced by estimate_path_cost_size(), and postgresGetForeignPlan().

classifyConditions()

void classifyConditions	(	PlannerInfo *	root,
		RelOptInfo *	baserel,
		List *	input_conds,
		List **	remote_conds,
		List **	local_conds
	)

Definition at line 218 of file deparse.c.

{
    ListCell   *lc;
 
    *remote_conds = NIL;
    *local_conds = NIL;
 
    foreach(lc, input_conds)
    {
        RestrictInfo *ri = lfirst_node(RestrictInfo, lc);
 
        if (is_foreign_expr(root, baserel, ri->clause))
            *remote_conds = lappend(*remote_conds, ri);
        else
            *local_conds = lappend(*local_conds, ri);
    }
}

References RestrictInfo::clause, is_foreign_expr(), lappend(), lfirst_node, NIL, and root.

Referenced by estimate_path_cost_size(), and postgresGetForeignRelSize().

deparseAnalyzeInfoSql()

void deparseAnalyzeInfoSql	(	StringInfo	buf,
		Relation	rel
	)

Definition at line 2521 of file deparse.c.

{
    StringInfoData relname;
 
    /* We'll need the remote relation name as a literal. */
    initStringInfo(&relname);
    deparseRelation(&relname, rel);
 
    appendStringInfoString(buf, "SELECT reltuples, relkind FROM pg_catalog.pg_class WHERE oid = ");
    deparseStringLiteral(buf, relname.data);
    appendStringInfoString(buf, "::pg_catalog.regclass");
}

References appendStringInfoString(), buf, nameData::data, deparseRelation(), deparseStringLiteral(), initStringInfo(), and relname.

Referenced by postgresGetAnalyzeInfoForForeignTable().

deparseAnalyzeSizeSql()

void deparseAnalyzeSizeSql	(	StringInfo	buf,
		Relation	rel
	)

Definition at line 2499 of file deparse.c.

{
    StringInfoData relname;
 
    /* We'll need the remote relation name as a literal. */
    initStringInfo(&relname);
    deparseRelation(&relname, rel);
 
    appendStringInfoString(buf, "SELECT pg_catalog.pg_relation_size(");
    deparseStringLiteral(buf, relname.data);
    appendStringInfo(buf, "::pg_catalog.regclass) / %d", BLCKSZ);
}

References appendStringInfo(), appendStringInfoString(), buf, nameData::data, deparseRelation(), deparseStringLiteral(), initStringInfo(), and relname.

Referenced by postgresAnalyzeForeignTable().

deparseAnalyzeSql()

void deparseAnalyzeSql	(	StringInfo	buf,
		Relation	rel,
		PgFdwSamplingMethod	sample_method,
		double	sample_frac,
		List **	retrieved_attrs
	)

Definition at line 2561 of file deparse.c.

{
    Oid         relid = RelationGetRelid(rel);
    TupleDesc   tupdesc = RelationGetDescr(rel);
    int         i;
    char       *colname;
    List       *options;
    ListCell   *lc;
    bool        first = true;
 
    *retrieved_attrs = NIL;
 
    appendStringInfoString(buf, "SELECT ");
    for (i = 0; i < tupdesc->natts; i++)
    {
        /* Ignore dropped columns. */
        if (TupleDescAttr(tupdesc, i)->attisdropped)
            continue;
 
        if (!first)
            appendStringInfoString(buf, ", ");
        first = false;
 
        /* Use attribute name or column_name option. */
        colname = NameStr(TupleDescAttr(tupdesc, i)->attname);
        options = GetForeignColumnOptions(relid, i + 1);
 
        foreach(lc, options)
        {
            DefElem    *def = (DefElem *) lfirst(lc);
 
            if (strcmp(def->defname, "column_name") == 0)
            {
                colname = defGetString(def);
                break;
            }
        }
 
        appendStringInfoString(buf, quote_identifier(colname));
 
        *retrieved_attrs = lappend_int(*retrieved_attrs, i + 1);
    }
 
    /* Don't generate bad syntax for zero-column relation. */
    if (first)
        appendStringInfoString(buf, "NULL");
 
    /*
     * Construct FROM clause, and perhaps WHERE clause too, depending on the
     * selected sampling method.
     */
    appendStringInfoString(buf, " FROM ");
    deparseRelation(buf, rel);
 
    switch (sample_method)
    {
        case ANALYZE_SAMPLE_OFF:
            /* nothing to do here */
            break;
 
        case ANALYZE_SAMPLE_RANDOM:
            appendStringInfo(buf, " WHERE pg_catalog.random() < %f", sample_frac);
            break;
 
        case ANALYZE_SAMPLE_SYSTEM:
            appendStringInfo(buf, " TABLESAMPLE SYSTEM(%f)", (100.0 * sample_frac));
            break;
 
        case ANALYZE_SAMPLE_BERNOULLI:
            appendStringInfo(buf, " TABLESAMPLE BERNOULLI(%f)", (100.0 * sample_frac));
            break;
 
        case ANALYZE_SAMPLE_AUTO:
            /* should have been resolved into actual method */
            elog(ERROR, "unexpected sampling method");
            break;
    }
}

References ANALYZE_SAMPLE_AUTO, ANALYZE_SAMPLE_BERNOULLI, ANALYZE_SAMPLE_OFF, ANALYZE_SAMPLE_RANDOM, ANALYZE_SAMPLE_SYSTEM, appendStringInfo(), appendStringInfoString(), attname, buf, defGetString(), DefElem::defname, deparseRelation(), elog, ERROR, GetForeignColumnOptions(), i, lappend_int(), lfirst, NameStr, TupleDescData::natts, NIL, options, quote_identifier(), RelationGetDescr, RelationGetRelid, and TupleDescAttr.

Referenced by postgresAcquireSampleRowsFunc().

deparseDeleteSql()

void deparseDeleteSql	(	StringInfo	buf,
		RangeTblEntry *	rte,
		Index	rtindex,
		Relation	rel,
		List *	returningList,
		List **	retrieved_attrs
	)

Definition at line 2362 of file deparse.c.

{
    appendStringInfoString(buf, "DELETE FROM ");
    deparseRelation(buf, rel);
    appendStringInfoString(buf, " WHERE ctid = $1");
 
    deparseReturningList(buf, rte, rtindex, rel,
                         rel->trigdesc && rel->trigdesc->trig_delete_after_row,
                         NIL, returningList, retrieved_attrs);
}

References appendStringInfoString(), buf, deparseRelation(), deparseReturningList(), NIL, TriggerDesc::trig_delete_after_row, and RelationData::trigdesc.

Referenced by postgresPlanForeignModify().

deparseDirectDeleteSql()

void deparseDirectDeleteSql	(	StringInfo	buf,
		PlannerInfo *	root,
		Index	rtindex,
		Relation	rel,
		RelOptInfo *	foreignrel,
		List *	remote_conds,
		List **	params_list,
		List *	returningList,
		List **	retrieved_attrs
	)

Definition at line 2391 of file deparse.c.

{
    deparse_expr_cxt context;
    List       *additional_conds = NIL;
 
    /* Set up context struct for recursion */
    context.root = root;
    context.foreignrel = foreignrel;
    context.scanrel = foreignrel;
    context.buf = buf;
    context.params_list = params_list;
 
    appendStringInfoString(buf, "DELETE FROM ");
    deparseRelation(buf, rel);
    if (foreignrel->reloptkind == RELOPT_JOINREL)
        appendStringInfo(buf, " %s%d", REL_ALIAS_PREFIX, rtindex);
 
    if (foreignrel->reloptkind == RELOPT_JOINREL)
    {
        List       *ignore_conds = NIL;
 
        appendStringInfoString(buf, " USING ");
        deparseFromExprForRel(buf, root, foreignrel, true, rtindex,
                              &ignore_conds, &additional_conds, params_list);
        remote_conds = list_concat(remote_conds, ignore_conds);
    }
 
    appendWhereClause(remote_conds, additional_conds, &context);
 
    if (additional_conds != NIL)
        list_free_deep(additional_conds);
 
    if (foreignrel->reloptkind == RELOPT_JOINREL)
        deparseExplicitTargetList(returningList, true, retrieved_attrs,
                                  &context);
    else
        deparseReturningList(buf, planner_rt_fetch(rtindex, root),
                             rtindex, rel, false,
                             NIL, returningList, retrieved_attrs);
}

References appendStringInfo(), appendStringInfoString(), appendWhereClause(), buf, context, deparseExplicitTargetList(), deparseFromExprForRel(), deparseRelation(), deparseReturningList(), list_concat(), list_free_deep(), NIL, planner_rt_fetch, REL_ALIAS_PREFIX, RELOPT_JOINREL, RelOptInfo::reloptkind, and root.

Referenced by postgresPlanDirectModify().

deparseDirectUpdateSql()

void deparseDirectUpdateSql	(	StringInfo	buf,
		PlannerInfo *	root,
		Index	rtindex,
		Relation	rel,
		RelOptInfo *	foreignrel,
		List *	targetlist,
		List *	targetAttrs,
		List *	remote_conds,
		List **	params_list,
		List *	returningList,
		List **	retrieved_attrs
	)

Definition at line 2276 of file deparse.c.

{
    deparse_expr_cxt context;
    int         nestlevel;
    bool        first;
    RangeTblEntry *rte = planner_rt_fetch(rtindex, root);
    ListCell   *lc,
               *lc2;
    List       *additional_conds = NIL;
 
    /* Set up context struct for recursion */
    context.root = root;
    context.foreignrel = foreignrel;
    context.scanrel = foreignrel;
    context.buf = buf;
    context.params_list = params_list;
 
    appendStringInfoString(buf, "UPDATE ");
    deparseRelation(buf, rel);
    if (foreignrel->reloptkind == RELOPT_JOINREL)
        appendStringInfo(buf, " %s%d", REL_ALIAS_PREFIX, rtindex);
    appendStringInfoString(buf, " SET ");
 
    /* Make sure any constants in the exprs are printed portably */
    nestlevel = set_transmission_modes();
 
    first = true;
    forboth(lc, targetlist, lc2, targetAttrs)
    {
        TargetEntry *tle = lfirst_node(TargetEntry, lc);
        int         attnum = lfirst_int(lc2);
 
        /* update's new-value expressions shouldn't be resjunk */
        Assert(!tle->resjunk);
 
        if (!first)
            appendStringInfoString(buf, ", ");
        first = false;
 
        deparseColumnRef(buf, rtindex, attnum, rte, false);
        appendStringInfoString(buf, " = ");
        deparseExpr((Expr *) tle->expr, &context);
    }
 
    reset_transmission_modes(nestlevel);
 
    if (foreignrel->reloptkind == RELOPT_JOINREL)
    {
        List       *ignore_conds = NIL;
 
 
        appendStringInfoString(buf, " FROM ");
        deparseFromExprForRel(buf, root, foreignrel, true, rtindex,
                              &ignore_conds, &additional_conds, params_list);
        remote_conds = list_concat(remote_conds, ignore_conds);
    }
 
    appendWhereClause(remote_conds, additional_conds, &context);
 
    if (additional_conds != NIL)
        list_free_deep(additional_conds);
 
    if (foreignrel->reloptkind == RELOPT_JOINREL)
        deparseExplicitTargetList(returningList, true, retrieved_attrs,
                                  &context);
    else
        deparseReturningList(buf, rte, rtindex, rel, false,
                             NIL, returningList, retrieved_attrs);
}

References appendStringInfo(), appendStringInfoString(), appendWhereClause(), Assert, attnum, buf, context, deparseColumnRef(), deparseExplicitTargetList(), deparseExpr(), deparseFromExprForRel(), deparseRelation(), deparseReturningList(), TargetEntry::expr, forboth, lfirst_int, lfirst_node, list_concat(), list_free_deep(), NIL, planner_rt_fetch, REL_ALIAS_PREFIX, RELOPT_JOINREL, RelOptInfo::reloptkind, reset_transmission_modes(), root, and set_transmission_modes().

Referenced by postgresPlanDirectModify().

deparseInsertSql()

void deparseInsertSql	(	StringInfo	buf,
		RangeTblEntry *	rte,
		Index	rtindex,
		Relation	rel,
		List *	targetAttrs,
		bool	doNothing,
		List *	withCheckOptionList,
		List *	returningList,
		List **	retrieved_attrs,
		int *	values_end_len
	)

Definition at line 2083 of file deparse.c.

{
    TupleDesc   tupdesc = RelationGetDescr(rel);
    AttrNumber  pindex;
    bool        first;
    ListCell   *lc;
 
    appendStringInfoString(buf, "INSERT INTO ");
    deparseRelation(buf, rel);
 
    if (targetAttrs)
    {
        appendStringInfoChar(buf, '(');
 
        first = true;
        foreach(lc, targetAttrs)
        {
            int         attnum = lfirst_int(lc);
 
            if (!first)
                appendStringInfoString(buf, ", ");
            first = false;
 
            deparseColumnRef(buf, rtindex, attnum, rte, false);
        }
 
        appendStringInfoString(buf, ") VALUES (");
 
        pindex = 1;
        first = true;
        foreach(lc, targetAttrs)
        {
            int         attnum = lfirst_int(lc);
            Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
 
            if (!first)
                appendStringInfoString(buf, ", ");
            first = false;
 
            if (attr->attgenerated)
                appendStringInfoString(buf, "DEFAULT");
            else
            {
                appendStringInfo(buf, "$%d", pindex);
                pindex++;
            }
        }
 
        appendStringInfoChar(buf, ')');
    }
    else
        appendStringInfoString(buf, " DEFAULT VALUES");
    *values_end_len = buf->len;
 
    if (doNothing)
        appendStringInfoString(buf, " ON CONFLICT DO NOTHING");
 
    deparseReturningList(buf, rte, rtindex, rel,
                         rel->trigdesc && rel->trigdesc->trig_insert_after_row,
                         withCheckOptionList, returningList, retrieved_attrs);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), attnum, buf, deparseColumnRef(), deparseRelation(), deparseReturningList(), lfirst_int, RelationGetDescr, TriggerDesc::trig_insert_after_row, RelationData::trigdesc, and TupleDescAttr.

Referenced by postgresBeginForeignInsert(), and postgresPlanForeignModify().

deparseSelectStmtForRel()

void deparseSelectStmtForRel	(	StringInfo	buf,
		PlannerInfo *	root,
		RelOptInfo *	rel,
		List *	tlist,
		List *	remote_conds,
		List *	pathkeys,
		bool	has_final_sort,
		bool	has_limit,
		bool	is_subquery,
		List **	retrieved_attrs,
		List **	params_list
	)

Definition at line 1233 of file deparse.c.

{
    deparse_expr_cxt context;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) rel->fdw_private;
    List       *quals;
 
    /*
     * We handle relations for foreign tables, joins between those and upper
     * relations.
     */
    Assert(IS_JOIN_REL(rel) || IS_SIMPLE_REL(rel) || IS_UPPER_REL(rel));
 
    /* Fill portions of context common to upper, join and base relation */
    context.buf = buf;
    context.root = root;
    context.foreignrel = rel;
    context.scanrel = IS_UPPER_REL(rel) ? fpinfo->outerrel : rel;
    context.params_list = params_list;
 
    /* Construct SELECT clause */
    deparseSelectSql(tlist, is_subquery, retrieved_attrs, &context);
 
    /*
     * For upper relations, the WHERE clause is built from the remote
     * conditions of the underlying scan relation; otherwise, we can use the
     * supplied list of remote conditions directly.
     */
    if (IS_UPPER_REL(rel))
    {
        PgFdwRelationInfo *ofpinfo;
 
        ofpinfo = (PgFdwRelationInfo *) fpinfo->outerrel->fdw_private;
        quals = ofpinfo->remote_conds;
    }
    else
        quals = remote_conds;
 
    /* Construct FROM and WHERE clauses */
    deparseFromExpr(quals, &context);
 
    if (IS_UPPER_REL(rel))
    {
        /* Append GROUP BY clause */
        appendGroupByClause(tlist, &context);
 
        /* Append HAVING clause */
        if (remote_conds)
        {
            appendStringInfoString(buf, " HAVING ");
            appendConditions(remote_conds, &context);
        }
    }
 
    /* Add ORDER BY clause if we found any useful pathkeys */
    if (pathkeys)
        appendOrderByClause(pathkeys, has_final_sort, &context);
 
    /* Add LIMIT clause if necessary */
    if (has_limit)
        appendLimitClause(&context);
 
    /* Add any necessary FOR UPDATE/SHARE. */
    deparseLockingClause(&context);
}

References appendConditions(), appendGroupByClause(), appendLimitClause(), appendOrderByClause(), appendStringInfoString(), Assert, buf, context, deparseFromExpr(), deparseLockingClause(), deparseSelectSql(), IS_JOIN_REL, IS_SIMPLE_REL, IS_UPPER_REL, PgFdwRelationInfo::outerrel, PgFdwRelationInfo::remote_conds, and root.

Referenced by deparseRangeTblRef(), estimate_path_cost_size(), and postgresGetForeignPlan().

deparseStringLiteral()

void deparseStringLiteral	(	StringInfo	buf,
		const char *	val
	)

Definition at line 2849 of file deparse.c.

{
    const char *valptr;
 
    /*
     * Rather than making assumptions about the remote server's value of
     * standard_conforming_strings, always use E'foo' syntax if there are any
     * backslashes.  This will fail on remote servers before 8.1, but those
     * are long out of support.
     */
    if (strchr(val, '\\') != NULL)
        appendStringInfoChar(buf, ESCAPE_STRING_SYNTAX);
    appendStringInfoChar(buf, '\'');
    for (valptr = val; *valptr; valptr++)
    {
        char        ch = *valptr;
 
        if (SQL_STR_DOUBLE(ch, true))
            appendStringInfoChar(buf, ch);
        appendStringInfoChar(buf, ch);
    }
    appendStringInfoChar(buf, '\'');
}

References appendStringInfoChar(), buf, ESCAPE_STRING_SYNTAX, SQL_STR_DOUBLE, and val.

Referenced by deparseAnalyzeInfoSql(), deparseAnalyzeSizeSql(), deparseConst(), and postgresImportForeignSchema().

deparseTruncateSql()

void deparseTruncateSql	(	StringInfo	buf,
		List *	rels,
		DropBehavior	behavior,
		bool	restart_seqs
	)

Definition at line 2646 of file deparse.c.

{
    ListCell   *cell;
 
    appendStringInfoString(buf, "TRUNCATE ");
 
    foreach(cell, rels)
    {
        Relation    rel = lfirst(cell);
 
        if (cell != list_head(rels))
            appendStringInfoString(buf, ", ");
 
        deparseRelation(buf, rel);
    }
 
    appendStringInfo(buf, " %s IDENTITY",
                     restart_seqs ? "RESTART" : "CONTINUE");
 
    if (behavior == DROP_RESTRICT)
        appendStringInfoString(buf, " RESTRICT");
    else if (behavior == DROP_CASCADE)
        appendStringInfoString(buf, " CASCADE");
}

References appendStringInfo(), appendStringInfoString(), buf, deparseRelation(), DROP_CASCADE, DROP_RESTRICT, lfirst, and list_head().

Referenced by postgresExecForeignTruncate().

deparseUpdateSql()

void deparseUpdateSql	(	StringInfo	buf,
		RangeTblEntry *	rte,
		Index	rtindex,
		Relation	rel,
		List *	targetAttrs,
		List *	withCheckOptionList,
		List *	returningList,
		List **	retrieved_attrs
	)

Definition at line 2216 of file deparse.c.

{
    TupleDesc   tupdesc = RelationGetDescr(rel);
    AttrNumber  pindex;
    bool        first;
    ListCell   *lc;
 
    appendStringInfoString(buf, "UPDATE ");
    deparseRelation(buf, rel);
    appendStringInfoString(buf, " SET ");
 
    pindex = 2;                 /* ctid is always the first param */
    first = true;
    foreach(lc, targetAttrs)
    {
        int         attnum = lfirst_int(lc);
        Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
 
        if (!first)
            appendStringInfoString(buf, ", ");
        first = false;
 
        deparseColumnRef(buf, rtindex, attnum, rte, false);
        if (attr->attgenerated)
            appendStringInfoString(buf, " = DEFAULT");
        else
        {
            appendStringInfo(buf, " = $%d", pindex);
            pindex++;
        }
    }
    appendStringInfoString(buf, " WHERE ctid = $1");
 
    deparseReturningList(buf, rte, rtindex, rel,
                         rel->trigdesc && rel->trigdesc->trig_update_after_row,
                         withCheckOptionList, returningList, retrieved_attrs);
}

References appendStringInfo(), appendStringInfoString(), attnum, buf, deparseColumnRef(), deparseRelation(), deparseReturningList(), lfirst_int, RelationGetDescr, TriggerDesc::trig_update_after_row, RelationData::trigdesc, and TupleDescAttr.

Referenced by postgresPlanForeignModify().

do_sql_command()

void do_sql_command	(	PGconn *	conn,
		const char *	sql
	)

Definition at line 699 of file connection.c.

{
    do_sql_command_begin(conn, sql);
    do_sql_command_end(conn, sql, false);
}

References conn, do_sql_command_begin(), and do_sql_command_end().

Referenced by begin_remote_xact(), configure_remote_session(), pgfdw_subxact_callback(), pgfdw_xact_callback(), and postgresExecForeignTruncate().

ExtractConnectionOptions()

int ExtractConnectionOptions	(	List *	defelems,
		const char **	keywords,
		const char **	values
	)

Definition at line 414 of file option.c.

{
    ListCell   *lc;
    int         i;
 
    /* Build our options lists if we didn't yet. */
    InitPgFdwOptions();
 
    i = 0;
    foreach(lc, defelems)
    {
        DefElem    *d = (DefElem *) lfirst(lc);
 
        if (is_libpq_option(d->defname))
        {
            keywords[i] = d->defname;
            values[i] = defGetString(d);
            i++;
        }
    }
    return i;
}

References defGetString(), DefElem::defname, i, InitPgFdwOptions(), is_libpq_option(), lfirst, and values.

Referenced by connect_pg_server().

ExtractExtensionList()

List* ExtractExtensionList	(	const char *	extensionsString,
		bool	warnOnMissing
	)

Definition at line 445 of file option.c.

{
    List       *extensionOids = NIL;
    List       *extlist;
    ListCell   *lc;
 
    /* SplitIdentifierString scribbles on its input, so pstrdup first */
    if (!SplitIdentifierString(pstrdup(extensionsString), ',', &extlist))
    {
        /* syntax error in name list */
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("parameter \"%s\" must be a list of extension names",
                        "extensions")));
    }
 
    foreach(lc, extlist)
    {
        const char *extension_name = (const char *) lfirst(lc);
        Oid         extension_oid = get_extension_oid(extension_name, true);
 
        if (OidIsValid(extension_oid))
        {
            extensionOids = lappend_oid(extensionOids, extension_oid);
        }
        else if (warnOnMissing)
        {
            ereport(WARNING,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("extension \"%s\" is not installed",
                            extension_name)));
        }
    }
 
    list_free(extlist);
    return extensionOids;
}

References ereport, errcode(), errmsg(), ERROR, get_extension_oid(), lappend_oid(), lfirst, list_free(), NIL, OidIsValid, pstrdup(), SplitIdentifierString(), and WARNING.

Referenced by apply_server_options(), and postgres_fdw_validator().

find_em_for_rel()

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

Definition at line 7776 of file postgres_fdw.c.

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

References bms_intersect(), bms_is_empty, bms_is_subset(), EquivalenceClass::ec_members, EquivalenceMember::em_expr, EquivalenceMember::em_relids, PgFdwRelationInfo::hidden_subquery_rels, is_foreign_expr(), lfirst, RelOptInfo::relids, and root.

Referenced by appendOrderByClause(), get_useful_pathkeys_for_relation(), and is_foreign_pathkey().

find_em_for_rel_target()

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

Definition at line 7812 of file postgres_fdw.c.

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

References arg, EquivalenceClass::ec_members, EquivalenceMember::em_expr, EquivalenceMember::em_is_child, EquivalenceMember::em_is_const, equal(), PathTarget::exprs, get_pathtarget_sortgroupref, get_sortgroupref_clause_noerr(), i, is_foreign_expr(), IsA, lfirst, RelOptInfo::reltarget, and root.

Referenced by add_foreign_ordered_paths(), and appendOrderByClause().

get_jointype_name()

const char* get_jointype_name

(

JoinType

jointype

)

Definition at line 1641 of file deparse.c.

{
    switch (jointype)
    {
        case JOIN_INNER:
            return "INNER";
 
        case JOIN_LEFT:
            return "LEFT";
 
        case JOIN_RIGHT:
            return "RIGHT";
 
        case JOIN_FULL:
            return "FULL";
 
        case JOIN_SEMI:
            return "SEMI";
 
        default:
            /* Shouldn't come here, but protect from buggy code. */
            elog(ERROR, "unsupported join type %d", jointype);
    }
 
    /* Keep compiler happy */
    return NULL;
}

References elog, ERROR, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_RIGHT, and JOIN_SEMI.

Referenced by deparseFromExprForRel(), and foreign_join_ok().

GetConnection()

PGconn* GetConnection	(	UserMapping *	user,
		bool	will_prep_stmt,
		PgFdwConnState **	state
	)

Definition at line 177 of file connection.c.

{
    bool        found;
    bool        retry = false;
    ConnCacheEntry *entry;
    ConnCacheKey key;
    MemoryContext ccxt = CurrentMemoryContext;
 
    /* First time through, initialize connection cache hashtable */
    if (ConnectionHash == NULL)
    {
        HASHCTL     ctl;
 
        if (pgfdw_we_get_result == 0)
            pgfdw_we_get_result =
                WaitEventExtensionNew("PostgresFdwGetResult");
 
        ctl.keysize = sizeof(ConnCacheKey);
        ctl.entrysize = sizeof(ConnCacheEntry);
        ConnectionHash = hash_create("postgres_fdw connections", 8,
                                     &ctl,
                                     HASH_ELEM | HASH_BLOBS);
 
        /*
         * Register some callback functions that manage connection cleanup.
         * This should be done just once in each backend.
         */
        RegisterXactCallback(pgfdw_xact_callback, NULL);
        RegisterSubXactCallback(pgfdw_subxact_callback, NULL);
        CacheRegisterSyscacheCallback(FOREIGNSERVEROID,
                                      pgfdw_inval_callback, (Datum) 0);
        CacheRegisterSyscacheCallback(USERMAPPINGOID,
                                      pgfdw_inval_callback, (Datum) 0);
    }
 
    /* Set flag that we did GetConnection during the current transaction */
    xact_got_connection = true;
 
    /* Create hash key for the entry.  Assume no pad bytes in key struct */
    key = user->umid;
 
    /*
     * Find or create cached entry for requested connection.
     */
    entry = hash_search(ConnectionHash, &key, HASH_ENTER, &found);
    if (!found)
    {
        /*
         * We need only clear "conn" here; remaining fields will be filled
         * later when "conn" is set.
         */
        entry->conn = NULL;
    }
 
    /* Reject further use of connections which failed abort cleanup. */
    pgfdw_reject_incomplete_xact_state_change(entry);
 
    /*
     * If the connection needs to be remade due to invalidation, disconnect as
     * soon as we're out of all transactions.
     */
    if (entry->conn != NULL && entry->invalidated && entry->xact_depth == 0)
    {
        elog(DEBUG3, "closing connection %p for option changes to take effect",
             entry->conn);
        disconnect_pg_server(entry);
    }
 
    /*
     * If cache entry doesn't have a connection, we have to establish a new
     * connection.  (If connect_pg_server throws an error, the cache entry
     * will remain in a valid empty state, ie conn == NULL.)
     */
    if (entry->conn == NULL)
        make_new_connection(entry, user);
 
    /*
     * We check the health of the cached connection here when using it.  In
     * cases where we're out of all transactions, if a broken connection is
     * detected, we try to reestablish a new connection later.
     */
    PG_TRY();
    {
        /* Process a pending asynchronous request if any. */
        if (entry->state.pendingAreq)
            process_pending_request(entry->state.pendingAreq);
        /* Start a new transaction or subtransaction if needed. */
        begin_remote_xact(entry);
    }
    PG_CATCH();
    {
        MemoryContext ecxt = MemoryContextSwitchTo(ccxt);
        ErrorData  *errdata = CopyErrorData();
 
        /*
         * Determine whether to try to reestablish the connection.
         *
         * After a broken connection is detected in libpq, any error other
         * than connection failure (e.g., out-of-memory) can be thrown
         * somewhere between return from libpq and the expected ereport() call
         * in pgfdw_report_error(). In this case, since PQstatus() indicates
         * CONNECTION_BAD, checking only PQstatus() causes the false detection
         * of connection failure. To avoid this, we also verify that the
         * error's sqlstate is ERRCODE_CONNECTION_FAILURE. Note that also
         * checking only the sqlstate can cause another false detection
         * because pgfdw_report_error() may report ERRCODE_CONNECTION_FAILURE
         * for any libpq-originated error condition.
         */
        if (errdata->sqlerrcode != ERRCODE_CONNECTION_FAILURE ||
            PQstatus(entry->conn) != CONNECTION_BAD ||
            entry->xact_depth > 0)
        {
            MemoryContextSwitchTo(ecxt);
            PG_RE_THROW();
        }
 
        /* Clean up the error state */
        FlushErrorState();
        FreeErrorData(errdata);
        errdata = NULL;
 
        retry = true;
    }
    PG_END_TRY();
 
    /*
     * If a broken connection is detected, disconnect it, reestablish a new
     * connection and retry a new remote transaction. If connection failure is
     * reported again, we give up getting a connection.
     */
    if (retry)
    {
        Assert(entry->xact_depth == 0);
 
        ereport(DEBUG3,
                (errmsg_internal("could not start remote transaction on connection %p",
                                 entry->conn)),
                errdetail_internal("%s", pchomp(PQerrorMessage(entry->conn))));
 
        elog(DEBUG3, "closing connection %p to reestablish a new one",
             entry->conn);
        disconnect_pg_server(entry);
 
        make_new_connection(entry, user);
 
        begin_remote_xact(entry);
    }
 
    /* Remember if caller will prepare statements */
    entry->have_prep_stmt |= will_prep_stmt;
 
    /* If caller needs access to the per-connection state, return it. */
    if (state)
        *state = &entry->state;
 
    return entry->conn;
}

References Assert, begin_remote_xact(), CacheRegisterSyscacheCallback(), ConnCacheEntry::conn, CONNECTION_BAD, ConnectionHash, CopyErrorData(), ctl, CurrentMemoryContext, DEBUG3, disconnect_pg_server(), elog, ereport, errdetail_internal(), errmsg_internal(), FlushErrorState(), FreeErrorData(), HASH_BLOBS, hash_create(), HASH_ELEM, HASH_ENTER, hash_search(), ConnCacheEntry::have_prep_stmt, ConnCacheEntry::invalidated, sort-test::key, make_new_connection(), MemoryContextSwitchTo(), pchomp(), PgFdwConnState::pendingAreq, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pgfdw_inval_callback(), pgfdw_reject_incomplete_xact_state_change(), pgfdw_subxact_callback(), pgfdw_we_get_result, pgfdw_xact_callback(), PQerrorMessage(), PQstatus(), process_pending_request(), RegisterSubXactCallback(), RegisterXactCallback(), ErrorData::sqlerrcode, ConnCacheEntry::state, user, WaitEventExtensionNew(), ConnCacheEntry::xact_depth, and xact_got_connection.

Referenced by create_foreign_modify(), dumpDatabase(), dumpDatabaseConfig(), dumpLOs(), dumpTableData_copy(), estimate_path_cost_size(), expand_extension_name_patterns(), expand_foreign_server_name_patterns(), expand_schema_name_patterns(), expand_table_name_patterns(), getTables(), main(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresBeginDirectModify(), postgresBeginForeignScan(), postgresExecForeignTruncate(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), setup_connection(), StartLogStreamer(), StreamLog(), and StreamLogicalLog().

GetCursorNumber()

unsigned int GetCursorNumber

(

PGconn *

conn

)

Definition at line 806 of file connection.c.

{
    return ++cursor_number;
}

References cursor_number.

Referenced by postgresAcquireSampleRowsFunc(), and postgresBeginForeignScan().

GetPrepStmtNumber()

unsigned int GetPrepStmtNumber

(

PGconn *

conn

)

Definition at line 820 of file connection.c.

{
    return ++prep_stmt_number;
}

References prep_stmt_number.

Referenced by prepare_foreign_modify().

is_builtin()

bool is_builtin

(

Oid

objectId

)

Definition at line 152 of file shippable.c.

{
    return (objectId < FirstGenbkiObjectId);
}

References FirstGenbkiObjectId.

Referenced by deparse_type_name(), and is_shippable().

is_foreign_expr()

bool is_foreign_expr	(	PlannerInfo *	root,
		RelOptInfo *	baserel,
		Expr *	expr
	)

Definition at line 244 of file deparse.c.

{
    foreign_glob_cxt glob_cxt;
    foreign_loc_cxt loc_cxt;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) (baserel->fdw_private);
 
    /*
     * Check that the expression consists of nodes that are safe to execute
     * remotely.
     */
    glob_cxt.root = root;
    glob_cxt.foreignrel = baserel;
 
    /*
     * For an upper relation, use relids from its underneath scan relation,
     * because the upperrel's own relids currently aren't set to anything
     * meaningful by the core code.  For other relation, use their own relids.
     */
    if (IS_UPPER_REL(baserel))
        glob_cxt.relids = fpinfo->outerrel->relids;
    else
        glob_cxt.relids = baserel->relids;
    loc_cxt.collation = InvalidOid;
    loc_cxt.state = FDW_COLLATE_NONE;
    if (!foreign_expr_walker((Node *) expr, &glob_cxt, &loc_cxt, NULL))
        return false;
 
    /*
     * If the expression has a valid collation that does not arise from a
     * foreign var, the expression can not be sent over.
     */
    if (loc_cxt.state == FDW_COLLATE_UNSAFE)
        return false;
 
    /*
     * An expression which includes any mutable functions can't be sent over
     * because its result is not stable.  For example, sending now() remote
     * side could cause confusion from clock offsets.  Future versions might
     * be able to make this choice with more granularity.  (We check this last
     * because it requires a lot of expensive catalog lookups.)
     */
    if (contain_mutable_functions((Node *) expr))
        return false;
 
    /* OK to evaluate on the remote server */
    return true;
}

References foreign_loc_cxt::collation, contain_mutable_functions(), FDW_COLLATE_NONE, FDW_COLLATE_UNSAFE, foreign_expr_walker(), foreign_glob_cxt::foreignrel, if(), InvalidOid, IS_UPPER_REL, PgFdwRelationInfo::outerrel, foreign_glob_cxt::relids, RelOptInfo::relids, foreign_glob_cxt::root, root, and foreign_loc_cxt::state.

Referenced by add_foreign_final_paths(), classifyConditions(), find_em_for_rel(), find_em_for_rel_target(), foreign_grouping_ok(), foreign_join_ok(), postgresGetForeignPaths(), postgresGetForeignPlan(), and postgresPlanDirectModify().

is_foreign_param()

bool is_foreign_param	(	PlannerInfo *	root,
		RelOptInfo *	baserel,
		Expr *	expr
	)

Definition at line 1082 of file deparse.c.

{
    if (expr == NULL)
        return false;
 
    switch (nodeTag(expr))
    {
        case T_Var:
            {
                /* It would have to be sent unless it's a foreign Var */
                Var        *var = (Var *) expr;
                PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) (baserel->fdw_private);
                Relids      relids;
 
                if (IS_UPPER_REL(baserel))
                    relids = fpinfo->outerrel->relids;
                else
                    relids = baserel->relids;
 
                if (bms_is_member(var->varno, relids) && var->varlevelsup == 0)
                    return false;   /* foreign Var, so not a param */
                else
                    return true;    /* it'd have to be a param */
                break;
            }
        case T_Param:
            /* Params always have to be sent to the foreign server */
            return true;
        default:
            break;
    }
    return false;
}

References bms_is_member(), if(), IS_UPPER_REL, nodeTag, PgFdwRelationInfo::outerrel, RelOptInfo::relids, Var::varlevelsup, and Var::varno.

Referenced by foreign_grouping_ok().

is_foreign_pathkey()

bool is_foreign_pathkey	(	PlannerInfo *	root,
		RelOptInfo *	baserel,
		PathKey *	pathkey
	)

Definition at line 1123 of file deparse.c.

{
    EquivalenceClass *pathkey_ec = pathkey->pk_eclass;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) baserel->fdw_private;
 
    /*
     * is_foreign_expr would detect volatile expressions as well, but checking
     * ec_has_volatile here saves some cycles.
     */
    if (pathkey_ec->ec_has_volatile)
        return false;
 
    /* can't push down the sort if the pathkey's opfamily is not shippable */
    if (!is_shippable(pathkey->pk_opfamily, OperatorFamilyRelationId, fpinfo))
        return false;
 
    /* can push if a suitable EC member exists */
    return (find_em_for_rel(root, pathkey_ec, baserel) != NULL);
}

References EquivalenceClass::ec_has_volatile, find_em_for_rel(), if(), is_shippable(), PathKey::pk_opfamily, and root.

Referenced by get_useful_pathkeys_for_relation().

is_shippable()

bool is_shippable	(	Oid	objectId,
		Oid	classId,
		PgFdwRelationInfo *	fpinfo
	)

Definition at line 162 of file shippable.c.

{
    ShippableCacheKey key;
    ShippableCacheEntry *entry;
 
    /* Built-in objects are presumed shippable. */
    if (is_builtin(objectId))
        return true;
 
    /* Otherwise, give up if user hasn't specified any shippable extensions. */
    if (fpinfo->shippable_extensions == NIL)
        return false;
 
    /* Initialize cache if first time through. */
    if (!ShippableCacheHash)
        InitializeShippableCache();
 
    /* Set up cache hash key */
    key.objid = objectId;
    key.classid = classId;
    key.serverid = fpinfo->server->serverid;
 
    /* See if we already cached the result. */
    entry = (ShippableCacheEntry *)
        hash_search(ShippableCacheHash, &key, HASH_FIND, NULL);
 
    if (!entry)
    {
        /* Not found in cache, so perform shippability lookup. */
        bool        shippable = lookup_shippable(objectId, classId, fpinfo);
 
        /*
         * Don't create a new hash entry until *after* we have the shippable
         * result in hand, as the underlying catalog lookups might trigger a
         * cache invalidation.
         */
        entry = (ShippableCacheEntry *)
            hash_search(ShippableCacheHash, &key, HASH_ENTER, NULL);
 
        entry->shippable = shippable;
    }
 
    return entry->shippable;
}

References HASH_ENTER, HASH_FIND, hash_search(), InitializeShippableCache(), is_builtin(), sort-test::key, lookup_shippable(), NIL, PgFdwRelationInfo::server, ForeignServer::serverid, ShippableCacheEntry::shippable, PgFdwRelationInfo::shippable_extensions, and ShippableCacheHash.

Referenced by add_foreign_ordered_paths(), foreign_expr_walker(), get_useful_pathkeys_for_relation(), and is_foreign_pathkey().

pgfdw_exec_query()

PGresult* pgfdw_exec_query	(	PGconn *	conn,
		const char *	query,
		PgFdwConnState *	state
	)

Definition at line 835 of file connection.c.

{
    /* First, process a pending asynchronous request, if any. */
    if (state && state->pendingAreq)
        process_pending_request(state->pendingAreq);
 
    if (!PQsendQuery(conn, query))
        return NULL;
    return pgfdw_get_result(conn);
}

References conn, pgfdw_get_result(), PQsendQuery(), and process_pending_request().

Referenced by close_cursor(), deallocate_query(), fetch_more_data(), get_remote_estimate(), pgfdw_xact_callback(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), and postgresReScanForeignScan().

pgfdw_get_result()

PGresult* pgfdw_get_result

(

PGconn *

conn

)

Definition at line 852 of file connection.c.

{
    return libpqsrv_get_result_last(conn, pgfdw_we_get_result);
}

References conn, libpqsrv_get_result_last(), and pgfdw_we_get_result.

Referenced by create_cursor(), do_sql_command_end(), execute_dml_stmt(), execute_foreign_modify(), fetch_more_data(), pgfdw_exec_query(), and prepare_foreign_modify().

pgfdw_report_error()

void pgfdw_report_error	(	int	elevel,
		PGresult *	res,
		PGconn *	conn,
		bool	clear,
		const char *	sql
	)

Definition at line 871 of file connection.c.

{
    /* If requested, PGresult must be released before leaving this function. */
    PG_TRY();
    {
        char       *diag_sqlstate = PQresultErrorField(res, PG_DIAG_SQLSTATE);
        char       *message_primary = PQresultErrorField(res, PG_DIAG_MESSAGE_PRIMARY);
        char       *message_detail = PQresultErrorField(res, PG_DIAG_MESSAGE_DETAIL);
        char       *message_hint = PQresultErrorField(res, PG_DIAG_MESSAGE_HINT);
        char       *message_context = PQresultErrorField(res, PG_DIAG_CONTEXT);
        int         sqlstate;
 
        if (diag_sqlstate)
            sqlstate = MAKE_SQLSTATE(diag_sqlstate[0],
                                     diag_sqlstate[1],
                                     diag_sqlstate[2],
                                     diag_sqlstate[3],
                                     diag_sqlstate[4]);
        else
            sqlstate = ERRCODE_CONNECTION_FAILURE;
 
        /*
         * If we don't get a message from the PGresult, try the PGconn.  This
         * is needed because for connection-level failures, PQgetResult may
         * just return NULL, not a PGresult at all.
         */
        if (message_primary == NULL)
            message_primary = pchomp(PQerrorMessage(conn));
 
        ereport(elevel,
                (errcode(sqlstate),
                 (message_primary != NULL && message_primary[0] != '\0') ?
                 errmsg_internal("%s", message_primary) :
                 errmsg("could not obtain message string for remote error"),
                 message_detail ? errdetail_internal("%s", message_detail) : 0,
                 message_hint ? errhint("%s", message_hint) : 0,
                 message_context ? errcontext("%s", message_context) : 0,
                 sql ? errcontext("remote SQL command: %s", sql) : 0));
    }
    PG_FINALLY();
    {
        if (clear)
            PQclear(res);
    }
    PG_END_TRY();
}

References conn, ereport, errcode(), errcontext, errdetail_internal(), errhint(), errmsg(), errmsg_internal(), MAKE_SQLSTATE, pchomp(), PG_DIAG_CONTEXT, PG_DIAG_MESSAGE_DETAIL, PG_DIAG_MESSAGE_HINT, PG_DIAG_MESSAGE_PRIMARY, PG_DIAG_SQLSTATE, PG_END_TRY, PG_FINALLY, PG_TRY, PQclear(), PQerrorMessage(), PQresultErrorField(), and res.

Referenced by close_cursor(), create_cursor(), deallocate_query(), do_sql_command_begin(), do_sql_command_end(), execute_dml_stmt(), execute_foreign_modify(), fetch_more_data(), fetch_more_data_begin(), get_remote_estimate(), pgfdw_exec_cleanup_query_begin(), pgfdw_exec_cleanup_query_end(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresForeignAsyncNotify(), postgresGetAnalyzeInfoForForeignTable(), postgresImportForeignSchema(), postgresReScanForeignScan(), and prepare_foreign_modify().

process_pending_request()

void process_pending_request

(

AsyncRequest *

areq

)

Definition at line 7449 of file postgres_fdw.c.

{
    ForeignScanState *node = (ForeignScanState *) areq->requestee;
    PgFdwScanState *fsstate = (PgFdwScanState *) node->fdw_state;
 
    /* The request would have been pending for a callback */
    Assert(areq->callback_pending);
 
    /* The request should be currently in-process */
    Assert(fsstate->conn_state->pendingAreq == areq);
 
    fetch_more_data(node);
 
    /*
     * If we didn't get any tuples, must be end of data; complete the request
     * now.  Otherwise, we postpone completing the request until we are called
     * from postgresForeignAsyncConfigureWait()/postgresForeignAsyncNotify().
     */
    if (fsstate->next_tuple >= fsstate->num_tuples)
    {
        /* Unlike AsyncNotify, we unset callback_pending ourselves */
        areq->callback_pending = false;
        /* Mark the request as complete */
        ExecAsyncRequestDone(areq, NULL);
        /* Unlike AsyncNotify, we call ExecAsyncResponse ourselves */
        ExecAsyncResponse(areq);
    }
}

References Assert, AsyncRequest::callback_pending, ExecAsyncRequestDone(), ExecAsyncResponse(), ForeignScanState::fdw_state, fetch_more_data(), and AsyncRequest::requestee.

Referenced by create_cursor(), execute_dml_stmt(), execute_foreign_modify(), GetConnection(), pgfdw_exec_query(), and postgresForeignAsyncConfigureWait().

process_pgfdw_appname()

char* process_pgfdw_appname

(

const char *

appname

)

Definition at line 491 of file option.c.

{
    const char *p;
    StringInfoData buf;
 
    initStringInfo(&buf);
 
    for (p = appname; *p != '\0'; p++)
    {
        if (*p != '%')
        {
            /* literal char, just copy */
            appendStringInfoChar(&buf, *p);
            continue;
        }
 
        /* must be a '%', so skip to the next char */
        p++;
        if (*p == '\0')
            break;              /* format error - ignore it */
        else if (*p == '%')
        {
            /* string contains %% */
            appendStringInfoChar(&buf, '%');
            continue;
        }
 
        /* process the option */
        switch (*p)
        {
            case 'a':
                appendStringInfoString(&buf, application_name);
                break;
            case 'c':
                appendStringInfo(&buf, "%lx.%x", (long) (MyStartTime), MyProcPid);
                break;
            case 'C':
                appendStringInfoString(&buf, cluster_name);
                break;
            case 'd':
                if (MyProcPort)
                {
                    const char *dbname = MyProcPort->database_name;
 
                    if (dbname)
                        appendStringInfoString(&buf, dbname);
                    else
                        appendStringInfoString(&buf, "[unknown]");
                }
                break;
            case 'p':
                appendStringInfo(&buf, "%d", MyProcPid);
                break;
            case 'u':
                if (MyProcPort)
                {
                    const char *username = MyProcPort->user_name;
 
                    if (username)
                        appendStringInfoString(&buf, username);
                    else
                        appendStringInfoString(&buf, "[unknown]");
                }
                break;
            default:
                /* format error - ignore it */
                break;
        }
    }
 
    return buf.data;
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), application_name, buf, cluster_name, Port::database_name, dbname, initStringInfo(), MyProcPid, MyProcPort, MyStartTime, Port::user_name, and username.

Referenced by connect_pg_server().

rebuildInsertSql()

void rebuildInsertSql	(	StringInfo	buf,
		Relation	rel,
		char *	orig_query,
		List *	target_attrs,
		int	values_end_len,
		int	num_params,
		int	num_rows
	)

Definition at line 2156 of file deparse.c.

{
    TupleDesc   tupdesc = RelationGetDescr(rel);
    int         i;
    int         pindex;
    bool        first;
    ListCell   *lc;
 
    /* Make sure the values_end_len is sensible */
    Assert((values_end_len > 0) && (values_end_len <= strlen(orig_query)));
 
    /* Copy up to the end of the first record from the original query */
    appendBinaryStringInfo(buf, orig_query, values_end_len);
 
    /*
     * Add records to VALUES clause (we already have parameters for the first
     * row, so start at the right offset).
     */
    pindex = num_params + 1;
    for (i = 0; i < num_rows; i++)
    {
        appendStringInfoString(buf, ", (");
 
        first = true;
        foreach(lc, target_attrs)
        {
            int         attnum = lfirst_int(lc);
            Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);
 
            if (!first)
                appendStringInfoString(buf, ", ");
            first = false;
 
            if (attr->attgenerated)
                appendStringInfoString(buf, "DEFAULT");
            else
            {
                appendStringInfo(buf, "$%d", pindex);
                pindex++;
            }
        }
 
        appendStringInfoChar(buf, ')');
    }
 
    /* Copy stuff after VALUES clause from the original query */
    appendStringInfoString(buf, orig_query + values_end_len);
}

References appendBinaryStringInfo(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert, attnum, buf, i, lfirst_int, RelationGetDescr, and TupleDescAttr.

Referenced by execute_foreign_modify().

ReleaseConnection()

void ReleaseConnection

(

PGconn *

conn

)

Definition at line 785 of file connection.c.

{
    /*
     * Currently, we don't actually track connection references because all
     * cleanup is managed on a transaction or subtransaction basis instead. So
     * there's nothing to do here.
     */
}

Referenced by estimate_path_cost_size(), finish_foreign_modify(), postgresAcquireSampleRowsFunc(), postgresAnalyzeForeignTable(), postgresEndDirectModify(), postgresEndForeignScan(), postgresGetAnalyzeInfoForForeignTable(), and postgresImportForeignSchema().

reset_transmission_modes()

void reset_transmission_modes

(

int

nestlevel

)

Definition at line 3923 of file postgres_fdw.c.

{
    AtEOXact_GUC(true, nestlevel);
}

References AtEOXact_GUC().

Referenced by appendConditions(), appendLimitClause(), appendOrderByClause(), convert_prep_stmt_params(), deparseDirectUpdateSql(), and process_query_params().

set_transmission_modes()

int set_transmission_modes

(

void

)

Definition at line 3887 of file postgres_fdw.c.

{
    int         nestlevel = NewGUCNestLevel();
 
    /*
     * The values set here should match what pg_dump does.  See also
     * configure_remote_session in connection.c.
     */
    if (DateStyle != USE_ISO_DATES)
        (void) set_config_option("datestyle", "ISO",
                                 PGC_USERSET, PGC_S_SESSION,
                                 GUC_ACTION_SAVE, true, 0, false);
    if (IntervalStyle != INTSTYLE_POSTGRES)
        (void) set_config_option("intervalstyle", "postgres",
                                 PGC_USERSET, PGC_S_SESSION,
                                 GUC_ACTION_SAVE, true, 0, false);
    if (extra_float_digits < 3)
        (void) set_config_option("extra_float_digits", "3",
                                 PGC_USERSET, PGC_S_SESSION,
                                 GUC_ACTION_SAVE, true, 0, false);
 
    /*
     * In addition force restrictive search_path, in case there are any
     * regproc or similar constants to be printed.
     */
    (void) set_config_option("search_path", "pg_catalog",
                             PGC_USERSET, PGC_S_SESSION,
                             GUC_ACTION_SAVE, true, 0, false);
 
    return nestlevel;
}

References DateStyle, extra_float_digits, GUC_ACTION_SAVE, IntervalStyle, INTSTYLE_POSTGRES, NewGUCNestLevel(), PGC_S_SESSION, PGC_USERSET, set_config_option(), and USE_ISO_DATES.

Referenced by appendConditions(), appendLimitClause(), appendOrderByClause(), convert_prep_stmt_params(), deparseDirectUpdateSql(), and process_query_params().

Variable Documentation

pgfdw_application_name

char* pgfdw_application_name

extern

Definition at line 52 of file option.c.

Referenced by _PG_init(), and connect_pg_server().