deparse.c File Reference

#include "postgres.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
#include "access/table.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_authid.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_database.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_ts_config.h"
#include "catalog/pg_ts_dict.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "nodes/nodeFuncs.h"
#include "nodes/plannodes.h"
#include "optimizer/optimizer.h"
#include "optimizer/prep.h"
#include "optimizer/tlist.h"
#include "parser/parsetree.h"
#include "postgres_fdw.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for deparse.c:

Go to the source code of this file.

Data Structures
struct	foreign_glob_cxt
struct	foreign_loc_cxt
struct	deparse_expr_cxt

Macros
#define	REL_ALIAS_PREFIX   "r"
#define	ADD_REL_QUALIFIER(buf, varno)    appendStringInfo((buf), "%s%d.", REL_ALIAS_PREFIX, (varno))
#define	SUBQUERY_REL_ALIAS_PREFIX   "s"
#define	SUBQUERY_COL_ALIAS_PREFIX   "c"

Typedefs
typedef struct foreign_glob_cxt	foreign_glob_cxt
typedef struct foreign_loc_cxt	foreign_loc_cxt
typedef struct deparse_expr_cxt	deparse_expr_cxt

Enumerations
enum	FDWCollateState { FDW_COLLATE_NONE , FDW_COLLATE_SAFE , FDW_COLLATE_UNSAFE }

Functions
static bool	foreign_expr_walker (Node *node, foreign_glob_cxt *glob_cxt, foreign_loc_cxt *outer_cxt, foreign_loc_cxt *case_arg_cxt)
static char *	deparse_type_name (Oid type_oid, int32 typemod)
static void	deparseTargetList (StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, bool is_returning, Bitmapset *attrs_used, bool qualify_col, List **retrieved_attrs)
static void	deparseExplicitTargetList (List *tlist, bool is_returning, List **retrieved_attrs, deparse_expr_cxt *context)
static void	deparseSubqueryTargetList (deparse_expr_cxt *context)
static void	deparseReturningList (StringInfo buf, RangeTblEntry *rte, Index rtindex, Relation rel, bool trig_after_row, List *withCheckOptionList, List *returningList, List **retrieved_attrs)
static void	deparseColumnRef (StringInfo buf, int varno, int varattno, RangeTblEntry *rte, bool qualify_col)
static void	deparseRelation (StringInfo buf, Relation rel)
static void	deparseExpr (Expr *node, deparse_expr_cxt *context)
static void	deparseVar (Var *node, deparse_expr_cxt *context)
static void	deparseConst (Const *node, deparse_expr_cxt *context, int showtype)
static void	deparseParam (Param *node, deparse_expr_cxt *context)
static void	deparseSubscriptingRef (SubscriptingRef *node, deparse_expr_cxt *context)
static void	deparseFuncExpr (FuncExpr *node, deparse_expr_cxt *context)
static void	deparseOpExpr (OpExpr *node, deparse_expr_cxt *context)
static bool	isPlainForeignVar (Expr *node, deparse_expr_cxt *context)
static void	deparseOperatorName (StringInfo buf, Form_pg_operator opform)
static void	deparseDistinctExpr (DistinctExpr *node, deparse_expr_cxt *context)
static void	deparseScalarArrayOpExpr (ScalarArrayOpExpr *node, deparse_expr_cxt *context)
static void	deparseRelabelType (RelabelType *node, deparse_expr_cxt *context)
static void	deparseArrayCoerceExpr (ArrayCoerceExpr *node, deparse_expr_cxt *context)
static void	deparseBoolExpr (BoolExpr *node, deparse_expr_cxt *context)
static void	deparseNullTest (NullTest *node, deparse_expr_cxt *context)
static void	deparseCaseExpr (CaseExpr *node, deparse_expr_cxt *context)
static void	deparseArrayExpr (ArrayExpr *node, deparse_expr_cxt *context)
static void	printRemoteParam (int paramindex, Oid paramtype, int32 paramtypmod, deparse_expr_cxt *context)
static void	printRemotePlaceholder (Oid paramtype, int32 paramtypmod, deparse_expr_cxt *context)
static void	deparseSelectSql (List *tlist, bool is_subquery, List **retrieved_attrs, deparse_expr_cxt *context)
static void	deparseLockingClause (deparse_expr_cxt *context)
static void	appendOrderByClause (List *pathkeys, bool has_final_sort, deparse_expr_cxt *context)
static void	appendLimitClause (deparse_expr_cxt *context)
static void	appendConditions (List *exprs, deparse_expr_cxt *context)
static void	deparseFromExprForRel (StringInfo buf, PlannerInfo *root, RelOptInfo *foreignrel, bool use_alias, Index ignore_rel, List **ignore_conds, List **additional_conds, List **params_list)
static void	appendWhereClause (List *exprs, List *additional_conds, deparse_expr_cxt *context)
static void	deparseFromExpr (List *quals, deparse_expr_cxt *context)
static void	deparseRangeTblRef (StringInfo buf, PlannerInfo *root, RelOptInfo *foreignrel, bool make_subquery, Index ignore_rel, List **ignore_conds, List **additional_conds, List **params_list)
static void	deparseAggref (Aggref *node, deparse_expr_cxt *context)
static void	appendGroupByClause (List *tlist, deparse_expr_cxt *context)
static void	appendOrderBySuffix (Oid sortop, Oid sortcoltype, bool nulls_first, deparse_expr_cxt *context)
static void	appendAggOrderBy (List *orderList, List *targetList, deparse_expr_cxt *context)
static void	appendFunctionName (Oid funcid, deparse_expr_cxt *context)
static Node *	deparseSortGroupClause (Index ref, List *tlist, bool force_colno, deparse_expr_cxt *context)
static bool	is_subquery_var (Var *node, RelOptInfo *foreignrel, int *relno, int *colno)
static void	get_relation_column_alias_ids (Var *node, RelOptInfo *foreignrel, int *relno, int *colno)
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)
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)
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)

Macro Definition Documentation

ADD_REL_QUALIFIER

#define ADD_REL_QUALIFIER	(		buf,
			varno
	)		appendStringInfo((buf), "%s%d.", REL_ALIAS_PREFIX, (varno))

Definition at line 111 of file deparse.c.

REL_ALIAS_PREFIX

#define REL_ALIAS_PREFIX   "r"

Definition at line 109 of file deparse.c.

SUBQUERY_COL_ALIAS_PREFIX

#define SUBQUERY_COL_ALIAS_PREFIX   "c"

Definition at line 114 of file deparse.c.

SUBQUERY_REL_ALIAS_PREFIX

#define SUBQUERY_REL_ALIAS_PREFIX   "s"

Definition at line 113 of file deparse.c.

Typedef Documentation

deparse_expr_cxt

typedef struct deparse_expr_cxt deparse_expr_cxt

foreign_glob_cxt

typedef struct foreign_glob_cxt foreign_glob_cxt

foreign_loc_cxt

typedef struct foreign_loc_cxt foreign_loc_cxt

Enumeration Type Documentation

FDWCollateState

enum FDWCollateState

Enumerator
FDW_COLLATE_NONE
FDW_COLLATE_SAFE
FDW_COLLATE_UNSAFE

Definition at line 79 of file deparse.c.

{
    FDW_COLLATE_NONE,           /* expression is of a noncollatable type, or
                                 * it has default collation that is not
                                 * traceable to a foreign Var */
    FDW_COLLATE_SAFE,           /* collation derives from a foreign Var */
    FDW_COLLATE_UNSAFE,         /* collation is non-default and derives from
                                 * something other than a foreign Var */
} FDWCollateState;

Function Documentation

appendAggOrderBy()

static void appendAggOrderBy ( List *  orderList, List *  targetList, deparse_expr_cxt *  context  )

static

Definition at line 3803 of file deparse.c.

{
    StringInfo  buf = context->buf;
    ListCell   *lc;
    bool        first = true;
 
    foreach(lc, orderList)
    {
        SortGroupClause *srt = (SortGroupClause *) lfirst(lc);
        Node       *sortexpr;
 
        if (!first)
            appendStringInfoString(buf, ", ");
        first = false;
 
        /* Deparse the sort expression proper. */
        sortexpr = deparseSortGroupClause(srt->tleSortGroupRef, targetList,
                                          false, context);
        /* Add decoration as needed. */
        appendOrderBySuffix(srt->sortop, exprType(sortexpr), srt->nulls_first,
                            context);
    }
}

References appendOrderBySuffix(), appendStringInfoString(), deparse_expr_cxt::buf, buf, deparseSortGroupClause(), exprType(), lfirst, SortGroupClause::nulls_first, SortGroupClause::sortop, and SortGroupClause::tleSortGroupRef.

Referenced by deparseAggref().

appendConditions()

static void appendConditions ( List *  exprs, deparse_expr_cxt *  context  )

static

Definition at line 1604 of file deparse.c.

{
    int         nestlevel;
    ListCell   *lc;
    bool        is_first = true;
    StringInfo  buf = context->buf;
 
    /* Make sure any constants in the exprs are printed portably */
    nestlevel = set_transmission_modes();
 
    foreach(lc, exprs)
    {
        Expr       *expr = (Expr *) lfirst(lc);
 
        /* Extract clause from RestrictInfo, if required */
        if (IsA(expr, RestrictInfo))
            expr = ((RestrictInfo *) expr)->clause;
 
        /* Connect expressions with "AND" and parenthesize each condition. */
        if (!is_first)
            appendStringInfoString(buf, " AND ");
 
        appendStringInfoChar(buf, '(');
        deparseExpr(expr, context);
        appendStringInfoChar(buf, ')');
 
        is_first = false;
    }
 
    reset_transmission_modes(nestlevel);
}

References appendStringInfoChar(), appendStringInfoString(), deparse_expr_cxt::buf, buf, deparseExpr(), IsA, lfirst, reset_transmission_modes(), and set_transmission_modes().

Referenced by appendWhereClause(), deparseFromExprForRel(), and deparseSelectStmtForRel().

appendFunctionName()

static void appendFunctionName ( Oid  funcid, deparse_expr_cxt *  context  )

static

Definition at line 4086 of file deparse.c.

{
    StringInfo  buf = context->buf;
    HeapTuple   proctup;
    Form_pg_proc procform;
    const char *proname;
 
    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(funcid));
    if (!HeapTupleIsValid(proctup))
        elog(ERROR, "cache lookup failed for function %u", funcid);
    procform = (Form_pg_proc) GETSTRUCT(proctup);
 
    /* Print schema name only if it's not pg_catalog */
    if (procform->pronamespace != PG_CATALOG_NAMESPACE)
    {
        const char *schemaname;
 
        schemaname = get_namespace_name(procform->pronamespace);
        appendStringInfo(buf, "%s.", quote_identifier(schemaname));
    }
 
    /* Always print the function name */
    proname = NameStr(procform->proname);
    appendStringInfoString(buf, quote_identifier(proname));
 
    ReleaseSysCache(proctup);
}

References appendStringInfo(), appendStringInfoString(), deparse_expr_cxt::buf, buf, elog, ERROR, get_namespace_name(), GETSTRUCT(), HeapTupleIsValid, NameStr, ObjectIdGetDatum(), proname, quote_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by deparseAggref(), and deparseFuncExpr().

appendGroupByClause()

static void appendGroupByClause ( List *  tlist, deparse_expr_cxt *  context  )

static

Definition at line 3916 of file deparse.c.

{
    StringInfo  buf = context->buf;
    Query      *query = context->root->parse;
    ListCell   *lc;
    bool        first = true;
 
    /* Nothing to be done, if there's no GROUP BY clause in the query. */
    if (!query->groupClause)
        return;
 
    appendStringInfoString(buf, " GROUP BY ");
 
    /*
     * Queries with grouping sets are not pushed down, so we don't expect
     * grouping sets here.
     */
    Assert(!query->groupingSets);
 
    /*
     * We intentionally print query->groupClause not processed_groupClause,
     * leaving it to the remote planner to get rid of any redundant GROUP BY
     * items again.  This is necessary in case processed_groupClause reduced
     * to empty, and in any case the redundancy situation on the remote might
     * be different than what we think here.
     */
    foreach(lc, query->groupClause)
    {
        SortGroupClause *grp = (SortGroupClause *) lfirst(lc);
 
        if (!first)
            appendStringInfoString(buf, ", ");
        first = false;
 
        deparseSortGroupClause(grp->tleSortGroupRef, tlist, true, context);
    }
}

References appendStringInfoString(), Assert(), deparse_expr_cxt::buf, buf, deparseSortGroupClause(), Query::groupClause, Query::groupingSets, lfirst, PlannerInfo::parse, deparse_expr_cxt::root, and SortGroupClause::tleSortGroupRef.

Referenced by deparseSelectStmtForRel().

appendLimitClause()

static void appendLimitClause ( deparse_expr_cxt *  context )

static

Definition at line 4058 of file deparse.c.

{
    PlannerInfo *root = context->root;
    StringInfo  buf = context->buf;
    int         nestlevel;
 
    /* Make sure any constants in the exprs are printed portably */
    nestlevel = set_transmission_modes();
 
    if (root->parse->limitCount)
    {
        appendStringInfoString(buf, " LIMIT ");
        deparseExpr((Expr *) root->parse->limitCount, context);
    }
    if (root->parse->limitOffset)
    {
        appendStringInfoString(buf, " OFFSET ");
        deparseExpr((Expr *) root->parse->limitOffset, context);
    }
 
    reset_transmission_modes(nestlevel);
}

References appendStringInfoString(), deparse_expr_cxt::buf, buf, deparseExpr(), reset_transmission_modes(), deparse_expr_cxt::root, root, and set_transmission_modes().

Referenced by deparseSelectStmtForRel().

appendOrderByClause()

static void appendOrderByClause ( List *  pathkeys, bool  has_final_sort, deparse_expr_cxt *  context  )

static

Definition at line 3964 of file deparse.c.

{
    ListCell   *lcell;
    int         nestlevel;
    StringInfo  buf = context->buf;
    bool        gotone = false;
 
    /* Make sure any constants in the exprs are printed portably */
    nestlevel = set_transmission_modes();
 
    foreach(lcell, pathkeys)
    {
        PathKey    *pathkey = lfirst(lcell);
        EquivalenceMember *em;
        Expr       *em_expr;
        Oid         oprid;
 
        if (has_final_sort)
        {
            /*
             * By construction, context->foreignrel is the input relation to
             * the final sort.
             */
            em = find_em_for_rel_target(context->root,
                                        pathkey->pk_eclass,
                                        context->foreignrel);
        }
        else
            em = find_em_for_rel(context->root,
                                 pathkey->pk_eclass,
                                 context->scanrel);
 
        /*
         * We don't expect any error here; it would mean that shippability
         * wasn't verified earlier.  For the same reason, we don't recheck
         * shippability of the sort operator.
         */
        if (em == NULL)
            elog(ERROR, "could not find pathkey item to sort");
 
        em_expr = em->em_expr;
 
        /*
         * If the member is a Const expression then we needn't add it to the
         * ORDER BY clause.  This can happen in UNION ALL queries where the
         * union child targetlist has a Const.  Adding these would be
         * wasteful, but also, for INT columns, an integer literal would be
         * seen as an ordinal column position rather than a value to sort by.
         * deparseConst() does have code to handle this, but it seems less
         * effort on all accounts just to skip these for ORDER BY clauses.
         */
        if (IsA(em_expr, Const))
            continue;
 
        if (!gotone)
        {
            appendStringInfoString(buf, " ORDER BY ");
            gotone = true;
        }
        else
            appendStringInfoString(buf, ", ");
 
        /*
         * Lookup the operator corresponding to the compare type in the
         * opclass. The datatype used by the opfamily is not necessarily the
         * same as the expression type (for array types for example).
         */
        oprid = get_opfamily_member_for_cmptype(pathkey->pk_opfamily,
                                                em->em_datatype,
                                                em->em_datatype,
                                                pathkey->pk_cmptype);
        if (!OidIsValid(oprid))
            elog(ERROR, "missing operator %d(%u,%u) in opfamily %u",
                 pathkey->pk_cmptype, em->em_datatype, em->em_datatype,
                 pathkey->pk_opfamily);
 
        deparseExpr(em_expr, context);
 
        /*
         * Here we need to use the expression's actual type to discover
         * whether the desired operator will be the default or not.
         */
        appendOrderBySuffix(oprid, exprType((Node *) em_expr),
                            pathkey->pk_nulls_first, context);
 
    }
    reset_transmission_modes(nestlevel);
}

References appendOrderBySuffix(), appendStringInfoString(), deparse_expr_cxt::buf, buf, deparseExpr(), elog, EquivalenceMember::em_datatype, EquivalenceMember::em_expr, ERROR, exprType(), find_em_for_rel(), find_em_for_rel_target(), deparse_expr_cxt::foreignrel, get_opfamily_member_for_cmptype(), IsA, lfirst, OidIsValid, oprid(), PathKey::pk_cmptype, PathKey::pk_nulls_first, PathKey::pk_opfamily, reset_transmission_modes(), deparse_expr_cxt::root, deparse_expr_cxt::scanrel, and set_transmission_modes().

Referenced by deparseSelectStmtForRel().

appendOrderBySuffix()

static void appendOrderBySuffix ( Oid  sortop, Oid  sortcoltype, bool  nulls_first, deparse_expr_cxt *  context  )

static

Definition at line 3832 of file deparse.c.

{
    StringInfo  buf = context->buf;
    TypeCacheEntry *typentry;
 
    /* See whether operator is default < or > for sort expr's datatype. */
    typentry = lookup_type_cache(sortcoltype,
                                 TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
 
    if (sortop == typentry->lt_opr)
        appendStringInfoString(buf, " ASC");
    else if (sortop == typentry->gt_opr)
        appendStringInfoString(buf, " DESC");
    else
    {
        HeapTuple   opertup;
        Form_pg_operator operform;
 
        appendStringInfoString(buf, " USING ");
 
        /* Append operator name. */
        opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(sortop));
        if (!HeapTupleIsValid(opertup))
            elog(ERROR, "cache lookup failed for operator %u", sortop);
        operform = (Form_pg_operator) GETSTRUCT(opertup);
        deparseOperatorName(buf, operform);
        ReleaseSysCache(opertup);
    }
 
    if (nulls_first)
        appendStringInfoString(buf, " NULLS FIRST");
    else
        appendStringInfoString(buf, " NULLS LAST");
}

References appendStringInfoString(), deparse_expr_cxt::buf, buf, deparseOperatorName(), elog, ERROR, GETSTRUCT(), TypeCacheEntry::gt_opr, HeapTupleIsValid, lookup_type_cache(), TypeCacheEntry::lt_opr, ObjectIdGetDatum(), ReleaseSysCache(), SearchSysCache1(), TYPECACHE_GT_OPR, and TYPECACHE_LT_OPR.

Referenced by appendAggOrderBy(), and appendOrderByClause().

appendWhereClause()

static void appendWhereClause ( List *  exprs, List *  additional_conds, deparse_expr_cxt *  context  )

static

Definition at line 1641 of file deparse.c.

{
    StringInfo  buf = context->buf;
    bool        need_and = false;
    ListCell   *lc;
 
    if (exprs != NIL || additional_conds != NIL)
        appendStringInfoString(buf, " WHERE ");
 
    /*
     * If there are some filters, append them.
     */
    if (exprs != NIL)
    {
        appendConditions(exprs, context);
        need_and = true;
    }
 
    /*
     * If there are some EXISTS conditions, coming from SEMI-JOINS, append
     * them.
     */
    foreach(lc, additional_conds)
    {
        if (need_and)
            appendStringInfoString(buf, " AND ");
        appendStringInfoString(buf, (char *) lfirst(lc));
        need_and = true;
    }
}

References appendConditions(), appendStringInfoString(), deparse_expr_cxt::buf, buf, lfirst, and NIL.

Referenced by deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseFromExpr(), and deparseFromExprForRel().

build_tlist_to_deparse()

List * build_tlist_to_deparse

(

RelOptInfo *

foreignrel

)

Definition at line 1209 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().

deparse_type_name()

static char * deparse_type_name ( Oid  type_oid, int32  typemod  )

static

Definition at line 1190 of file deparse.c.

{
    bits16      flags = FORMAT_TYPE_TYPEMOD_GIVEN;
 
    if (!is_builtin(type_oid))
        flags |= FORMAT_TYPE_FORCE_QUALIFY;
 
    return format_type_extended(type_oid, typemod, flags);
}

References format_type_extended(), FORMAT_TYPE_FORCE_QUALIFY, FORMAT_TYPE_TYPEMOD_GIVEN, and is_builtin().

Referenced by deparseArrayCoerceExpr(), deparseArrayExpr(), deparseConst(), deparseFuncExpr(), deparseRelabelType(), printRemoteParam(), and printRemotePlaceholder().

deparseAggref()

static void deparseAggref ( Aggref *  node, deparse_expr_cxt *  context  )

static

Definition at line 3711 of file deparse.c.

{
    StringInfo  buf = context->buf;
    bool        use_variadic;
 
    /* Only basic, non-split aggregation accepted. */
    Assert(node->aggsplit == AGGSPLIT_SIMPLE);
 
    /* Check if need to print VARIADIC (cf. ruleutils.c) */
    use_variadic = node->aggvariadic;
 
    /* Find aggregate name from aggfnoid which is a pg_proc entry */
    appendFunctionName(node->aggfnoid, context);
    appendStringInfoChar(buf, '(');
 
    /* Add DISTINCT */
    appendStringInfoString(buf, (node->aggdistinct != NIL) ? "DISTINCT " : "");
 
    if (AGGKIND_IS_ORDERED_SET(node->aggkind))
    {
        /* Add WITHIN GROUP (ORDER BY ..) */
        ListCell   *arg;
        bool        first = true;
 
        Assert(!node->aggvariadic);
        Assert(node->aggorder != NIL);
 
        foreach(arg, node->aggdirectargs)
        {
            if (!first)
                appendStringInfoString(buf, ", ");
            first = false;
 
            deparseExpr((Expr *) lfirst(arg), context);
        }
 
        appendStringInfoString(buf, ") WITHIN GROUP (ORDER BY ");
        appendAggOrderBy(node->aggorder, node->args, context);
    }
    else
    {
        /* aggstar can be set only in zero-argument aggregates */
        if (node->aggstar)
            appendStringInfoChar(buf, '*');
        else
        {
            ListCell   *arg;
            bool        first = true;
 
            /* Add all the arguments */
            foreach(arg, node->args)
            {
                TargetEntry *tle = (TargetEntry *) lfirst(arg);
                Node       *n = (Node *) tle->expr;
 
                if (tle->resjunk)
                    continue;
 
                if (!first)
                    appendStringInfoString(buf, ", ");
                first = false;
 
                /* Add VARIADIC */
                if (use_variadic && lnext(node->args, arg) == NULL)
                    appendStringInfoString(buf, "VARIADIC ");
 
                deparseExpr((Expr *) n, context);
            }
        }
 
        /* Add ORDER BY */
        if (node->aggorder != NIL)
        {
            appendStringInfoString(buf, " ORDER BY ");
            appendAggOrderBy(node->aggorder, node->args, context);
        }
    }
 
    /* Add FILTER (WHERE ..) */
    if (node->aggfilter != NULL)
    {
        appendStringInfoString(buf, ") FILTER (WHERE ");
        deparseExpr((Expr *) node->aggfilter, context);
    }
 
    appendStringInfoChar(buf, ')');
}

References Aggref::aggdirectargs, Aggref::aggdistinct, Aggref::aggfilter, Aggref::aggfnoid, Aggref::aggorder, AGGSPLIT_SIMPLE, appendAggOrderBy(), appendFunctionName(), appendStringInfoChar(), appendStringInfoString(), arg, Aggref::args, Assert(), deparse_expr_cxt::buf, buf, deparseExpr(), TargetEntry::expr, if(), lfirst, lnext(), and NIL.

Referenced by deparseExpr().

deparseAnalyzeInfoSql()

void deparseAnalyzeInfoSql	(	StringInfo	buf,
		Relation	rel
	)

Definition at line 2554 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 2532 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 2594 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().

deparseArrayCoerceExpr()

static void deparseArrayCoerceExpr ( ArrayCoerceExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3546 of file deparse.c.

{
    deparseExpr(node->arg, context);
 
    /*
     * No difference how to deparse explicit cast, but if we omit implicit
     * cast in the query, it'll be more user-friendly
     */
    if (node->coerceformat != COERCE_IMPLICIT_CAST)
        appendStringInfo(context->buf, "::%s",
                         deparse_type_name(node->resulttype,
                                           node->resulttypmod));
}

References appendStringInfo(), ArrayCoerceExpr::arg, deparse_expr_cxt::buf, COERCE_IMPLICIT_CAST, deparse_type_name(), deparseExpr(), and ArrayCoerceExpr::resulttype.

Referenced by deparseExpr().

deparseArrayExpr()

static void deparseArrayExpr ( ArrayExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3685 of file deparse.c.

{
    StringInfo  buf = context->buf;
    bool        first = true;
    ListCell   *lc;
 
    appendStringInfoString(buf, "ARRAY[");
    foreach(lc, node->elements)
    {
        if (!first)
            appendStringInfoString(buf, ", ");
        deparseExpr(lfirst(lc), context);
        first = false;
    }
    appendStringInfoChar(buf, ']');
 
    /* If the array is empty, we need an explicit cast to the array type. */
    if (node->elements == NIL)
        appendStringInfo(buf, "::%s",
                         deparse_type_name(node->array_typeid, -1));
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), deparse_expr_cxt::buf, buf, deparse_type_name(), deparseExpr(), lfirst, and NIL.

Referenced by deparseExpr().

deparseBoolExpr()

static void deparseBoolExpr ( BoolExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3564 of file deparse.c.

{
    StringInfo  buf = context->buf;
    const char *op = NULL;      /* keep compiler quiet */
    bool        first;
    ListCell   *lc;
 
    switch (node->boolop)
    {
        case AND_EXPR:
            op = "AND";
            break;
        case OR_EXPR:
            op = "OR";
            break;
        case NOT_EXPR:
            appendStringInfoString(buf, "(NOT ");
            deparseExpr(linitial(node->args), context);
            appendStringInfoChar(buf, ')');
            return;
    }
 
    appendStringInfoChar(buf, '(');
    first = true;
    foreach(lc, node->args)
    {
        if (!first)
            appendStringInfo(buf, " %s ", op);
        deparseExpr((Expr *) lfirst(lc), context);
        first = false;
    }
    appendStringInfoChar(buf, ')');
}

References AND_EXPR, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), BoolExpr::args, BoolExpr::boolop, deparse_expr_cxt::buf, buf, deparseExpr(), lfirst, linitial, NOT_EXPR, and OR_EXPR.

Referenced by deparseExpr().

deparseCaseExpr()

static void deparseCaseExpr ( CaseExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3635 of file deparse.c.

{
    StringInfo  buf = context->buf;
    ListCell   *lc;
 
    appendStringInfoString(buf, "(CASE");
 
    /* If this is a CASE arg WHEN then emit the arg expression */
    if (node->arg != NULL)
    {
        appendStringInfoChar(buf, ' ');
        deparseExpr(node->arg, context);
    }
 
    /* Add each condition/result of the CASE clause */
    foreach(lc, node->args)
    {
        CaseWhen   *whenclause = (CaseWhen *) lfirst(lc);
 
        /* WHEN */
        appendStringInfoString(buf, " WHEN ");
        if (node->arg == NULL)  /* CASE WHEN */
            deparseExpr(whenclause->expr, context);
        else                    /* CASE arg WHEN */
        {
            /* Ignore the CaseTestExpr and equality operator. */
            deparseExpr(lsecond(castNode(OpExpr, whenclause->expr)->args),
                        context);
        }
 
        /* THEN */
        appendStringInfoString(buf, " THEN ");
        deparseExpr(whenclause->result, context);
    }
 
    /* add ELSE if present */
    if (node->defresult != NULL)
    {
        appendStringInfoString(buf, " ELSE ");
        deparseExpr(node->defresult, context);
    }
 
    /* append END */
    appendStringInfoString(buf, " END)");
}

References appendStringInfoChar(), appendStringInfoString(), CaseExpr::arg, CaseExpr::args, deparse_expr_cxt::buf, buf, castNode, CaseExpr::defresult, deparseExpr(), CaseWhen::expr, lfirst, lsecond, and CaseWhen::result.

Referenced by deparseExpr().

deparseColumnRef()

static void deparseColumnRef ( StringInfo  buf, int  varno, int  varattno, RangeTblEntry *  rte, bool  qualify_col  )

static

Definition at line 2714 of file deparse.c.

{
    /* We support fetching the remote side's CTID and OID. */
    if (varattno == SelfItemPointerAttributeNumber)
    {
        if (qualify_col)
            ADD_REL_QUALIFIER(buf, varno);
        appendStringInfoString(buf, "ctid");
    }
    else if (varattno < 0)
    {
        /*
         * All other system attributes are fetched as 0, except for table OID,
         * which is fetched as the local table OID.  However, we must be
         * careful; the table could be beneath an outer join, in which case it
         * must go to NULL whenever the rest of the row does.
         */
        Oid         fetchval = 0;
 
        if (varattno == TableOidAttributeNumber)
            fetchval = rte->relid;
 
        if (qualify_col)
        {
            appendStringInfoString(buf, "CASE WHEN (");
            ADD_REL_QUALIFIER(buf, varno);
            appendStringInfo(buf, "*)::text IS NOT NULL THEN %u END", fetchval);
        }
        else
            appendStringInfo(buf, "%u", fetchval);
    }
    else if (varattno == 0)
    {
        /* Whole row reference */
        Relation    rel;
        Bitmapset  *attrs_used;
 
        /* Required only to be passed down to deparseTargetList(). */
        List       *retrieved_attrs;
 
        /*
         * The lock on the relation will be held by upper callers, so it's
         * fine to open it with no lock here.
         */
        rel = table_open(rte->relid, NoLock);
 
        /*
         * The local name of the foreign table can not be recognized by the
         * foreign server and the table it references on foreign server might
         * have different column ordering or different columns than those
         * declared locally. Hence we have to deparse whole-row reference as
         * ROW(columns referenced locally). Construct this by deparsing a
         * "whole row" attribute.
         */
        attrs_used = bms_add_member(NULL,
                                    0 - FirstLowInvalidHeapAttributeNumber);
 
        /*
         * In case the whole-row reference is under an outer join then it has
         * to go NULL whenever the rest of the row goes NULL. Deparsing a join
         * query would always involve multiple relations, thus qualify_col
         * would be true.
         */
        if (qualify_col)
        {
            appendStringInfoString(buf, "CASE WHEN (");
            ADD_REL_QUALIFIER(buf, varno);
            appendStringInfoString(buf, "*)::text IS NOT NULL THEN ");
        }
 
        appendStringInfoString(buf, "ROW(");
        deparseTargetList(buf, rte, varno, rel, false, attrs_used, qualify_col,
                          &retrieved_attrs);
        appendStringInfoChar(buf, ')');
 
        /* Complete the CASE WHEN statement started above. */
        if (qualify_col)
            appendStringInfoString(buf, " END");
 
        table_close(rel, NoLock);
        bms_free(attrs_used);
    }
    else
    {
        char       *colname = NULL;
        List       *options;
        ListCell   *lc;
 
        /* varno must not be any of OUTER_VAR, INNER_VAR and INDEX_VAR. */
        Assert(!IS_SPECIAL_VARNO(varno));
 
        /*
         * If it's a column of a foreign table, and it has the column_name FDW
         * option, use that value.
         */
        options = GetForeignColumnOptions(rte->relid, varattno);
        foreach(lc, options)
        {
            DefElem    *def = (DefElem *) lfirst(lc);
 
            if (strcmp(def->defname, "column_name") == 0)
            {
                colname = defGetString(def);
                break;
            }
        }
 
        /*
         * If it's a column of a regular table or it doesn't have column_name
         * FDW option, use attribute name.
         */
        if (colname == NULL)
            colname = get_attname(rte->relid, varattno, false);
 
        if (qualify_col)
            ADD_REL_QUALIFIER(buf, varno);
 
        appendStringInfoString(buf, quote_identifier(colname));
    }
}

References ADD_REL_QUALIFIER, appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), bms_add_member(), bms_free(), buf, defGetString(), DefElem::defname, deparseTargetList(), FirstLowInvalidHeapAttributeNumber, get_attname(), GetForeignColumnOptions(), IS_SPECIAL_VARNO, lfirst, NoLock, options, quote_identifier(), SelfItemPointerAttributeNumber, table_close(), table_open(), and TableOidAttributeNumber.

Referenced by deparseDirectUpdateSql(), deparseInsertSql(), deparseTargetList(), deparseUpdateSql(), and deparseVar().

deparseConst()

static void deparseConst ( Const *  node, deparse_expr_cxt *  context, int  showtype  )

static

Definition at line 3056 of file deparse.c.

{
    StringInfo  buf = context->buf;
    Oid         typoutput;
    bool        typIsVarlena;
    char       *extval;
    bool        isfloat = false;
    bool        isstring = false;
    bool        needlabel;
 
    if (node->constisnull)
    {
        appendStringInfoString(buf, "NULL");
        if (showtype >= 0)
            appendStringInfo(buf, "::%s",
                             deparse_type_name(node->consttype,
                                               node->consttypmod));
        return;
    }
 
    getTypeOutputInfo(node->consttype,
                      &typoutput, &typIsVarlena);
    extval = OidOutputFunctionCall(typoutput, node->constvalue);
 
    switch (node->consttype)
    {
        case INT2OID:
        case INT4OID:
        case INT8OID:
        case OIDOID:
        case FLOAT4OID:
        case FLOAT8OID:
        case NUMERICOID:
            {
                /*
                 * No need to quote unless it's a special value such as 'NaN'.
                 * See comments in get_const_expr().
                 */
                if (strspn(extval, "0123456789+-eE.") == strlen(extval))
                {
                    if (extval[0] == '+' || extval[0] == '-')
                        appendStringInfo(buf, "(%s)", extval);
                    else
                        appendStringInfoString(buf, extval);
                    if (strcspn(extval, "eE.") != strlen(extval))
                        isfloat = true; /* it looks like a float */
                }
                else
                    appendStringInfo(buf, "'%s'", extval);
            }
            break;
        case BITOID:
        case VARBITOID:
            appendStringInfo(buf, "B'%s'", extval);
            break;
        case BOOLOID:
            if (strcmp(extval, "t") == 0)
                appendStringInfoString(buf, "true");
            else
                appendStringInfoString(buf, "false");
            break;
        default:
            deparseStringLiteral(buf, extval);
            isstring = true;
            break;
    }
 
    pfree(extval);
 
    if (showtype == -1)
        return;                 /* never print type label */
 
    /*
     * For showtype == 0, append ::typename unless the constant will be
     * implicitly typed as the right type when it is read in.
     *
     * XXX this code has to be kept in sync with the behavior of the parser,
     * especially make_const.
     */
    switch (node->consttype)
    {
        case BOOLOID:
        case INT4OID:
        case UNKNOWNOID:
            needlabel = false;
            break;
        case NUMERICOID:
            needlabel = !isfloat || (node->consttypmod >= 0);
            break;
        default:
            if (showtype == -2)
            {
                /* label unless we printed it as an untyped string */
                needlabel = !isstring;
            }
            else
                needlabel = true;
            break;
    }
    if (needlabel || showtype > 0)
        appendStringInfo(buf, "::%s",
                         deparse_type_name(node->consttype,
                                           node->consttypmod));
}

References appendStringInfo(), appendStringInfoString(), deparse_expr_cxt::buf, buf, Const::consttype, deparse_type_name(), deparseStringLiteral(), getTypeOutputInfo(), OidOutputFunctionCall(), and pfree().

Referenced by deparseExpr(), deparseOpExpr(), and deparseSortGroupClause().

deparseDeleteSql()

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

Definition at line 2395 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 2424 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(), deparse_expr_cxt::buf, buf, deparseExplicitTargetList(), deparseFromExprForRel(), deparseRelation(), deparseReturningList(), deparse_expr_cxt::foreignrel, list_concat(), list_free_deep(), NIL, deparse_expr_cxt::params_list, planner_rt_fetch, REL_ALIAS_PREFIX, RELOPT_JOINREL, RelOptInfo::reloptkind, deparse_expr_cxt::root, root, and deparse_expr_cxt::scanrel.

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 2309 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, deparse_expr_cxt::buf, buf, deparseColumnRef(), deparseExplicitTargetList(), deparseExpr(), deparseFromExprForRel(), deparseRelation(), deparseReturningList(), TargetEntry::expr, forboth, deparse_expr_cxt::foreignrel, lfirst_int, lfirst_node, list_concat(), list_free_deep(), NIL, deparse_expr_cxt::params_list, planner_rt_fetch, REL_ALIAS_PREFIX, RELOPT_JOINREL, RelOptInfo::reloptkind, reset_transmission_modes(), deparse_expr_cxt::root, root, deparse_expr_cxt::scanrel, and set_transmission_modes().

Referenced by postgresPlanDirectModify().

deparseDistinctExpr()

static void deparseDistinctExpr ( DistinctExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3470 of file deparse.c.

{
    StringInfo  buf = context->buf;
 
    Assert(list_length(node->args) == 2);
 
    appendStringInfoChar(buf, '(');
    deparseExpr(linitial(node->args), context);
    appendStringInfoString(buf, " IS DISTINCT FROM ");
    deparseExpr(lsecond(node->args), context);
    appendStringInfoChar(buf, ')');
}

References appendStringInfoChar(), appendStringInfoString(), OpExpr::args, Assert(), deparse_expr_cxt::buf, buf, deparseExpr(), linitial, list_length(), and lsecond.

Referenced by deparseExpr().

deparseExplicitTargetList()

static void deparseExplicitTargetList ( List *  tlist, bool  is_returning, List **  retrieved_attrs, deparse_expr_cxt *  context  )

static

Definition at line 1714 of file deparse.c.

{
    ListCell   *lc;
    StringInfo  buf = context->buf;
    int         i = 0;
 
    *retrieved_attrs = NIL;
 
    foreach(lc, tlist)
    {
        TargetEntry *tle = lfirst_node(TargetEntry, lc);
 
        if (i > 0)
            appendStringInfoString(buf, ", ");
        else if (is_returning)
            appendStringInfoString(buf, " RETURNING ");
 
        deparseExpr((Expr *) tle->expr, context);
 
        *retrieved_attrs = lappend_int(*retrieved_attrs, i + 1);
        i++;
    }
 
    if (i == 0 && !is_returning)
        appendStringInfoString(buf, "NULL");
}

References appendStringInfoString(), deparse_expr_cxt::buf, buf, deparseExpr(), TargetEntry::expr, i, lappend_int(), lfirst_node, and NIL.

Referenced by deparseDirectDeleteSql(), deparseDirectUpdateSql(), and deparseSelectSql().

deparseExpr()

static void deparseExpr ( Expr *  node, deparse_expr_cxt *  context  )

static

Definition at line 2917 of file deparse.c.

{
    if (node == NULL)
        return;
 
    switch (nodeTag(node))
    {
        case T_Var:
            deparseVar((Var *) node, context);
            break;
        case T_Const:
            deparseConst((Const *) node, context, 0);
            break;
        case T_Param:
            deparseParam((Param *) node, context);
            break;
        case T_SubscriptingRef:
            deparseSubscriptingRef((SubscriptingRef *) node, context);
            break;
        case T_FuncExpr:
            deparseFuncExpr((FuncExpr *) node, context);
            break;
        case T_OpExpr:
            deparseOpExpr((OpExpr *) node, context);
            break;
        case T_DistinctExpr:
            deparseDistinctExpr((DistinctExpr *) node, context);
            break;
        case T_ScalarArrayOpExpr:
            deparseScalarArrayOpExpr((ScalarArrayOpExpr *) node, context);
            break;
        case T_RelabelType:
            deparseRelabelType((RelabelType *) node, context);
            break;
        case T_ArrayCoerceExpr:
            deparseArrayCoerceExpr((ArrayCoerceExpr *) node, context);
            break;
        case T_BoolExpr:
            deparseBoolExpr((BoolExpr *) node, context);
            break;
        case T_NullTest:
            deparseNullTest((NullTest *) node, context);
            break;
        case T_CaseExpr:
            deparseCaseExpr((CaseExpr *) node, context);
            break;
        case T_ArrayExpr:
            deparseArrayExpr((ArrayExpr *) node, context);
            break;
        case T_Aggref:
            deparseAggref((Aggref *) node, context);
            break;
        default:
            elog(ERROR, "unsupported expression type for deparse: %d",
                 (int) nodeTag(node));
            break;
    }
}

References deparseAggref(), deparseArrayCoerceExpr(), deparseArrayExpr(), deparseBoolExpr(), deparseCaseExpr(), deparseConst(), deparseDistinctExpr(), deparseFuncExpr(), deparseNullTest(), deparseOpExpr(), deparseParam(), deparseRelabelType(), deparseScalarArrayOpExpr(), deparseSubscriptingRef(), deparseVar(), elog, ERROR, and nodeTag.

Referenced by appendConditions(), appendLimitClause(), appendOrderByClause(), deparseAggref(), deparseArrayCoerceExpr(), deparseArrayExpr(), deparseBoolExpr(), deparseCaseExpr(), deparseDirectUpdateSql(), deparseDistinctExpr(), deparseExplicitTargetList(), deparseFuncExpr(), deparseNullTest(), deparseOpExpr(), deparseRelabelType(), deparseScalarArrayOpExpr(), deparseSortGroupClause(), deparseSubqueryTargetList(), and deparseSubscriptingRef().

deparseFromExpr()

static void deparseFromExpr ( List *  quals, deparse_expr_cxt *  context  )

static

Definition at line 1406 of file deparse.c.

{
    StringInfo  buf = context->buf;
    RelOptInfo *scanrel = context->scanrel;
    List       *additional_conds = NIL;
 
    /* For upper relations, scanrel must be either a joinrel or a baserel */
    Assert(!IS_UPPER_REL(context->foreignrel) ||
           IS_JOIN_REL(scanrel) || IS_SIMPLE_REL(scanrel));
 
    /* Construct FROM clause */
    appendStringInfoString(buf, " FROM ");
    deparseFromExprForRel(buf, context->root, scanrel,
                          (bms_membership(scanrel->relids) == BMS_MULTIPLE),
                          (Index) 0, NULL, &additional_conds,
                          context->params_list);
    appendWhereClause(quals, additional_conds, context);
    if (additional_conds != NIL)
        list_free_deep(additional_conds);
}

References appendStringInfoString(), appendWhereClause(), Assert(), bms_membership(), BMS_MULTIPLE, deparse_expr_cxt::buf, buf, deparseFromExprForRel(), deparse_expr_cxt::foreignrel, IS_JOIN_REL, IS_SIMPLE_REL, IS_UPPER_REL, list_free_deep(), NIL, deparse_expr_cxt::params_list, RelOptInfo::relids, deparse_expr_cxt::root, and deparse_expr_cxt::scanrel.

Referenced by deparseSelectStmtForRel().

deparseFromExprForRel()

static void deparseFromExprForRel ( StringInfo  buf, PlannerInfo *  root, RelOptInfo *  foreignrel, bool  use_alias, Index  ignore_rel, List **  ignore_conds, List **  additional_conds, List **  params_list  )

static

Definition at line 1794 of file deparse.c.

{
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
 
    if (IS_JOIN_REL(foreignrel))
    {
        StringInfoData join_sql_o;
        StringInfoData join_sql_i;
        RelOptInfo *outerrel = fpinfo->outerrel;
        RelOptInfo *innerrel = fpinfo->innerrel;
        bool        outerrel_is_target = false;
        bool        innerrel_is_target = false;
        List       *additional_conds_i = NIL;
        List       *additional_conds_o = NIL;
 
        if (ignore_rel > 0 && bms_is_member(ignore_rel, foreignrel->relids))
        {
            /*
             * If this is an inner join, add joinclauses to *ignore_conds and
             * set it to empty so that those can be deparsed into the WHERE
             * clause.  Note that since the target relation can never be
             * within the nullable side of an outer join, those could safely
             * be pulled up into the WHERE clause (see foreign_join_ok()).
             * Note also that since the target relation is only inner-joined
             * to any other relation in the query, all conditions in the join
             * tree mentioning the target relation could be deparsed into the
             * WHERE clause by doing this recursively.
             */
            if (fpinfo->jointype == JOIN_INNER)
            {
                *ignore_conds = list_concat(*ignore_conds,
                                            fpinfo->joinclauses);
                fpinfo->joinclauses = NIL;
            }
 
            /*
             * Check if either of the input relations is the target relation.
             */
            if (outerrel->relid == ignore_rel)
                outerrel_is_target = true;
            else if (innerrel->relid == ignore_rel)
                innerrel_is_target = true;
        }
 
        /* Deparse outer relation if not the target relation. */
        if (!outerrel_is_target)
        {
            initStringInfo(&join_sql_o);
            deparseRangeTblRef(&join_sql_o, root, outerrel,
                               fpinfo->make_outerrel_subquery,
                               ignore_rel, ignore_conds, &additional_conds_o,
                               params_list);
 
            /*
             * If inner relation is the target relation, skip deparsing it.
             * Note that since the join of the target relation with any other
             * relation in the query is an inner join and can never be within
             * the nullable side of an outer join, the join could be
             * interchanged with higher-level joins (cf. identity 1 on outer
             * join reordering shown in src/backend/optimizer/README), which
             * means it's safe to skip the target-relation deparsing here.
             */
            if (innerrel_is_target)
            {
                Assert(fpinfo->jointype == JOIN_INNER);
                Assert(fpinfo->joinclauses == NIL);
                appendBinaryStringInfo(buf, join_sql_o.data, join_sql_o.len);
                /* Pass EXISTS conditions to upper level */
                if (additional_conds_o != NIL)
                {
                    Assert(*additional_conds == NIL);
                    *additional_conds = additional_conds_o;
                }
                return;
            }
        }
 
        /* Deparse inner relation if not the target relation. */
        if (!innerrel_is_target)
        {
            initStringInfo(&join_sql_i);
            deparseRangeTblRef(&join_sql_i, root, innerrel,
                               fpinfo->make_innerrel_subquery,
                               ignore_rel, ignore_conds, &additional_conds_i,
                               params_list);
 
            /*
             * SEMI-JOIN is deparsed as the EXISTS subquery. It references
             * outer and inner relations, so it should be evaluated as the
             * condition in the upper-level WHERE clause. We deparse the
             * condition and pass it to upper level callers as an
             * additional_conds list. Upper level callers are responsible for
             * inserting conditions from the list where appropriate.
             */
            if (fpinfo->jointype == JOIN_SEMI)
            {
                deparse_expr_cxt context;
                StringInfoData str;
 
                /* Construct deparsed condition from this SEMI-JOIN */
                initStringInfo(&str);
                appendStringInfo(&str, "EXISTS (SELECT NULL FROM %s",
                                 join_sql_i.data);
 
                context.buf = &str;
                context.foreignrel = foreignrel;
                context.scanrel = foreignrel;
                context.root = root;
                context.params_list = params_list;
 
                /*
                 * Append SEMI-JOIN clauses and EXISTS conditions from lower
                 * levels to the current EXISTS subquery
                 */
                appendWhereClause(fpinfo->joinclauses, additional_conds_i, &context);
 
                /*
                 * EXISTS conditions, coming from lower join levels, have just
                 * been processed.
                 */
                if (additional_conds_i != NIL)
                {
                    list_free_deep(additional_conds_i);
                    additional_conds_i = NIL;
                }
 
                /* Close parentheses for EXISTS subquery */
                appendStringInfoChar(&str, ')');
 
                *additional_conds = lappend(*additional_conds, str.data);
            }
 
            /*
             * If outer relation is the target relation, skip deparsing it.
             * See the above note about safety.
             */
            if (outerrel_is_target)
            {
                Assert(fpinfo->jointype == JOIN_INNER);
                Assert(fpinfo->joinclauses == NIL);
                appendBinaryStringInfo(buf, join_sql_i.data, join_sql_i.len);
                /* Pass EXISTS conditions to the upper call */
                if (additional_conds_i != NIL)
                {
                    Assert(*additional_conds == NIL);
                    *additional_conds = additional_conds_i;
                }
                return;
            }
        }
 
        /* Neither of the relations is the target relation. */
        Assert(!outerrel_is_target && !innerrel_is_target);
 
        /*
         * For semijoin FROM clause is deparsed as an outer relation. An inner
         * relation and join clauses are converted to EXISTS condition and
         * passed to the upper level.
         */
        if (fpinfo->jointype == JOIN_SEMI)
        {
            appendBinaryStringInfo(buf, join_sql_o.data, join_sql_o.len);
        }
        else
        {
            /*
             * For a join relation FROM clause, entry is deparsed as
             *
             * ((outer relation) <join type> (inner relation) ON
             * (joinclauses))
             */
            appendStringInfo(buf, "(%s %s JOIN %s ON ", join_sql_o.data,
                             get_jointype_name(fpinfo->jointype), join_sql_i.data);
 
            /* Append join clause; (TRUE) if no join clause */
            if (fpinfo->joinclauses)
            {
                deparse_expr_cxt context;
 
                context.buf = buf;
                context.foreignrel = foreignrel;
                context.scanrel = foreignrel;
                context.root = root;
                context.params_list = params_list;
 
                appendStringInfoChar(buf, '(');
                appendConditions(fpinfo->joinclauses, &context);
                appendStringInfoChar(buf, ')');
            }
            else
                appendStringInfoString(buf, "(TRUE)");
 
            /* End the FROM clause entry. */
            appendStringInfoChar(buf, ')');
        }
 
        /*
         * Construct additional_conds to be passed to the upper caller from
         * current level additional_conds and additional_conds, coming from
         * inner and outer rels.
         */
        if (additional_conds_o != NIL)
        {
            *additional_conds = list_concat(*additional_conds,
                                            additional_conds_o);
            list_free(additional_conds_o);
        }
 
        if (additional_conds_i != NIL)
        {
            *additional_conds = list_concat(*additional_conds,
                                            additional_conds_i);
            list_free(additional_conds_i);
        }
    }
    else
    {
        RangeTblEntry *rte = planner_rt_fetch(foreignrel->relid, root);
 
        /*
         * Core code already has some lock on each rel being planned, so we
         * can use NoLock here.
         */
        Relation    rel = table_open(rte->relid, NoLock);
 
        deparseRelation(buf, rel);
 
        /*
         * Add a unique alias to avoid any conflict in relation names due to
         * pulled up subqueries in the query being built for a pushed down
         * join.
         */
        if (use_alias)
            appendStringInfo(buf, " %s%d", REL_ALIAS_PREFIX, foreignrel->relid);
 
        table_close(rel, NoLock);
    }
}

References appendBinaryStringInfo(), appendConditions(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), appendWhereClause(), Assert(), bms_is_member(), deparse_expr_cxt::buf, buf, StringInfoData::data, deparseRangeTblRef(), deparseRelation(), deparse_expr_cxt::foreignrel, get_jointype_name(), if(), initStringInfo(), PgFdwRelationInfo::innerrel, IS_JOIN_REL, JOIN_INNER, JOIN_SEMI, PgFdwRelationInfo::joinclauses, PgFdwRelationInfo::jointype, lappend(), StringInfoData::len, list_concat(), list_free(), list_free_deep(), PgFdwRelationInfo::make_innerrel_subquery, PgFdwRelationInfo::make_outerrel_subquery, NIL, NoLock, PgFdwRelationInfo::outerrel, deparse_expr_cxt::params_list, planner_rt_fetch, REL_ALIAS_PREFIX, RelOptInfo::relid, RelOptInfo::relids, deparse_expr_cxt::root, root, deparse_expr_cxt::scanrel, str, table_close(), and table_open().

Referenced by deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseFromExpr(), and deparseRangeTblRef().

deparseFuncExpr()

static void deparseFuncExpr ( FuncExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3249 of file deparse.c.

{
    StringInfo  buf = context->buf;
    bool        use_variadic;
    bool        first;
    ListCell   *arg;
 
    /*
     * If the function call came from an implicit coercion, then just show the
     * first argument.
     */
    if (node->funcformat == COERCE_IMPLICIT_CAST)
    {
        deparseExpr((Expr *) linitial(node->args), context);
        return;
    }
 
    /*
     * If the function call came from a cast, then show the first argument
     * plus an explicit cast operation.
     */
    if (node->funcformat == COERCE_EXPLICIT_CAST)
    {
        Oid         rettype = node->funcresulttype;
        int32       coercedTypmod;
 
        /* Get the typmod if this is a length-coercion function */
        (void) exprIsLengthCoercion((Node *) node, &coercedTypmod);
 
        deparseExpr((Expr *) linitial(node->args), context);
        appendStringInfo(buf, "::%s",
                         deparse_type_name(rettype, coercedTypmod));
        return;
    }
 
    /* Check if need to print VARIADIC (cf. ruleutils.c) */
    use_variadic = node->funcvariadic;
 
    /*
     * Normal function: display as proname(args).
     */
    appendFunctionName(node->funcid, context);
    appendStringInfoChar(buf, '(');
 
    /* ... and all the arguments */
    first = true;
    foreach(arg, node->args)
    {
        if (!first)
            appendStringInfoString(buf, ", ");
        if (use_variadic && lnext(node->args, arg) == NULL)
            appendStringInfoString(buf, "VARIADIC ");
        deparseExpr((Expr *) lfirst(arg), context);
        first = false;
    }
    appendStringInfoChar(buf, ')');
}

References appendFunctionName(), appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), arg, FuncExpr::args, deparse_expr_cxt::buf, buf, COERCE_EXPLICIT_CAST, COERCE_IMPLICIT_CAST, deparse_type_name(), deparseExpr(), exprIsLengthCoercion(), FuncExpr::funcid, lfirst, linitial, and lnext().

Referenced by deparseExpr().

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 2116 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().

deparseLockingClause()

static void deparseLockingClause ( deparse_expr_cxt *  context )

static

Definition at line 1514 of file deparse.c.

{
    StringInfo  buf = context->buf;
    PlannerInfo *root = context->root;
    RelOptInfo *rel = context->scanrel;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) rel->fdw_private;
    int         relid = -1;
 
    while ((relid = bms_next_member(rel->relids, relid)) >= 0)
    {
        /*
         * Ignore relation if it appears in a lower subquery.  Locking clause
         * for such a relation is included in the subquery if necessary.
         */
        if (bms_is_member(relid, fpinfo->lower_subquery_rels))
            continue;
 
        /*
         * Add FOR UPDATE/SHARE if appropriate.  We apply locking during the
         * initial row fetch, rather than later on as is done for local
         * tables. The extra roundtrips involved in trying to duplicate the
         * local semantics exactly don't seem worthwhile (see also comments
         * for RowMarkType).
         *
         * Note: because we actually run the query as a cursor, this assumes
         * that DECLARE CURSOR ... FOR UPDATE is supported, which it isn't
         * before 8.3.
         */
        if (bms_is_member(relid, root->all_result_relids) &&
            (root->parse->commandType == CMD_UPDATE ||
             root->parse->commandType == CMD_DELETE))
        {
            /* Relation is UPDATE/DELETE target, so use FOR UPDATE */
            appendStringInfoString(buf, " FOR UPDATE");
 
            /* Add the relation alias if we are here for a join relation */
            if (IS_JOIN_REL(rel))
                appendStringInfo(buf, " OF %s%d", REL_ALIAS_PREFIX, relid);
        }
        else
        {
            PlanRowMark *rc = get_plan_rowmark(root->rowMarks, relid);
 
            if (rc)
            {
                /*
                 * Relation is specified as a FOR UPDATE/SHARE target, so
                 * handle that.  (But we could also see LCS_NONE, meaning this
                 * isn't a target relation after all.)
                 *
                 * For now, just ignore any [NO] KEY specification, since (a)
                 * it's not clear what that means for a remote table that we
                 * don't have complete information about, and (b) it wouldn't
                 * work anyway on older remote servers.  Likewise, we don't
                 * worry about NOWAIT.
                 */
                switch (rc->strength)
                {
                    case LCS_NONE:
                        /* No locking needed */
                        break;
                    case LCS_FORKEYSHARE:
                    case LCS_FORSHARE:
                        appendStringInfoString(buf, " FOR SHARE");
                        break;
                    case LCS_FORNOKEYUPDATE:
                    case LCS_FORUPDATE:
                        appendStringInfoString(buf, " FOR UPDATE");
                        break;
                }
 
                /* Add the relation alias if we are here for a join relation */
                if (bms_membership(rel->relids) == BMS_MULTIPLE &&
                    rc->strength != LCS_NONE)
                    appendStringInfo(buf, " OF %s%d", REL_ALIAS_PREFIX, relid);
            }
        }
    }
}

References appendStringInfo(), appendStringInfoString(), bms_is_member(), bms_membership(), BMS_MULTIPLE, bms_next_member(), deparse_expr_cxt::buf, buf, CMD_DELETE, CMD_UPDATE, get_plan_rowmark(), IS_JOIN_REL, LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, LCS_NONE, PgFdwRelationInfo::lower_subquery_rels, REL_ALIAS_PREFIX, RelOptInfo::relids, deparse_expr_cxt::root, root, deparse_expr_cxt::scanrel, PlanRowMark::strength, and while().

Referenced by deparseSelectStmtForRel().

deparseNullTest()

static void deparseNullTest ( NullTest *  node, deparse_expr_cxt *  context  )

static

Definition at line 3602 of file deparse.c.

{
    StringInfo  buf = context->buf;
 
    appendStringInfoChar(buf, '(');
    deparseExpr(node->arg, context);
 
    /*
     * For scalar inputs, we prefer to print as IS [NOT] NULL, which is
     * shorter and traditional.  If it's a rowtype input but we're applying a
     * scalar test, must print IS [NOT] DISTINCT FROM NULL to be semantically
     * correct.
     */
    if (node->argisrow || !type_is_rowtype(exprType((Node *) node->arg)))
    {
        if (node->nulltesttype == IS_NULL)
            appendStringInfoString(buf, " IS NULL)");
        else
            appendStringInfoString(buf, " IS NOT NULL)");
    }
    else
    {
        if (node->nulltesttype == IS_NULL)
            appendStringInfoString(buf, " IS NOT DISTINCT FROM NULL)");
        else
            appendStringInfoString(buf, " IS DISTINCT FROM NULL)");
    }
}

References appendStringInfoChar(), appendStringInfoString(), NullTest::arg, deparse_expr_cxt::buf, buf, deparseExpr(), exprType(), IS_NULL, NullTest::nulltesttype, and type_is_rowtype().

Referenced by deparseExpr().

deparseOperatorName()

static void deparseOperatorName ( StringInfo  buf, Form_pg_operator  opform  )

static

Definition at line 3442 of file deparse.c.

{
    char       *opname;
 
    /* opname is not a SQL identifier, so we should not quote it. */
    opname = NameStr(opform->oprname);
 
    /* Print schema name only if it's not pg_catalog */
    if (opform->oprnamespace != PG_CATALOG_NAMESPACE)
    {
        const char *opnspname;
 
        opnspname = get_namespace_name(opform->oprnamespace);
        /* Print fully qualified operator name. */
        appendStringInfo(buf, "OPERATOR(%s.%s)",
                         quote_identifier(opnspname), opname);
    }
    else
    {
        /* Just print operator name. */
        appendStringInfoString(buf, opname);
    }
}

References appendStringInfo(), appendStringInfoString(), buf, get_namespace_name(), NameStr, and quote_identifier().

Referenced by appendOrderBySuffix(), deparseOpExpr(), and deparseScalarArrayOpExpr().

deparseOpExpr()

static void deparseOpExpr ( OpExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3312 of file deparse.c.

{
    StringInfo  buf = context->buf;
    HeapTuple   tuple;
    Form_pg_operator form;
    Expr       *right;
    bool        canSuppressRightConstCast = false;
    char        oprkind;
 
    /* Retrieve information about the operator from system catalog. */
    tuple = SearchSysCache1(OPEROID, ObjectIdGetDatum(node->opno));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for operator %u", node->opno);
    form = (Form_pg_operator) GETSTRUCT(tuple);
    oprkind = form->oprkind;
 
    /* Sanity check. */
    Assert((oprkind == 'l' && list_length(node->args) == 1) ||
           (oprkind == 'b' && list_length(node->args) == 2));
 
    right = llast(node->args);
 
    /* Always parenthesize the expression. */
    appendStringInfoChar(buf, '(');
 
    /* Deparse left operand, if any. */
    if (oprkind == 'b')
    {
        Expr       *left = linitial(node->args);
        Oid         leftType = exprType((Node *) left);
        Oid         rightType = exprType((Node *) right);
        bool        canSuppressLeftConstCast = false;
 
        /*
         * When considering a binary operator, if one operand is a Const that
         * can be printed as a bare string literal or NULL (i.e., it will look
         * like type UNKNOWN to the remote parser), the Const normally
         * receives an explicit cast to the operator's input type.  However,
         * in Const-to-Var comparisons where both operands are of the same
         * type, we prefer to suppress the explicit cast, leaving the Const's
         * type resolution up to the remote parser.  The remote's resolution
         * heuristic will assume that an unknown input type being compared to
         * a known input type is of that known type as well.
         *
         * This hack allows some cases to succeed where a remote column is
         * declared with a different type in the local (foreign) table.  By
         * emitting "foreigncol = 'foo'" not "foreigncol = 'foo'::text" or the
         * like, we allow the remote parser to pick an "=" operator that's
         * compatible with whatever type the remote column really is, such as
         * an enum.
         *
         * We allow cast suppression to happen only when the other operand is
         * a plain foreign Var.  Although the remote's unknown-type heuristic
         * would apply to other cases just as well, we would be taking a
         * bigger risk that the inferred type is something unexpected.  With
         * this restriction, if anything goes wrong it's the user's fault for
         * not declaring the local column with the same type as the remote
         * column.
         */
        if (leftType == rightType)
        {
            if (IsA(left, Const))
                canSuppressLeftConstCast = isPlainForeignVar(right, context);
            else if (IsA(right, Const))
                canSuppressRightConstCast = isPlainForeignVar(left, context);
        }
 
        if (canSuppressLeftConstCast)
            deparseConst((Const *) left, context, -2);
        else
            deparseExpr(left, context);
 
        appendStringInfoChar(buf, ' ');
    }
 
    /* Deparse operator name. */
    deparseOperatorName(buf, form);
 
    /* Deparse right operand. */
    appendStringInfoChar(buf, ' ');
 
    if (canSuppressRightConstCast)
        deparseConst((Const *) right, context, -2);
    else
        deparseExpr(right, context);
 
    appendStringInfoChar(buf, ')');
 
    ReleaseSysCache(tuple);
}

References appendStringInfoChar(), OpExpr::args, Assert(), deparse_expr_cxt::buf, buf, deparseConst(), deparseExpr(), deparseOperatorName(), elog, ERROR, exprType(), GETSTRUCT(), HeapTupleIsValid, IsA, isPlainForeignVar(), linitial, list_length(), llast, ObjectIdGetDatum(), OpExpr::opno, ReleaseSysCache(), and SearchSysCache1().

Referenced by deparseExpr().

deparseParam()

static void deparseParam ( Param *  node, deparse_expr_cxt *  context  )

static

Definition at line 3170 of file deparse.c.

{
    if (context->params_list)
    {
        int         pindex = 0;
        ListCell   *lc;
 
        /* find its index in params_list */
        foreach(lc, *context->params_list)
        {
            pindex++;
            if (equal(node, (Node *) lfirst(lc)))
                break;
        }
        if (lc == NULL)
        {
            /* not in list, so add it */
            pindex++;
            *context->params_list = lappend(*context->params_list, node);
        }
 
        printRemoteParam(pindex, node->paramtype, node->paramtypmod, context);
    }
    else
    {
        printRemotePlaceholder(node->paramtype, node->paramtypmod, context);
    }
}

References equal(), lappend(), lfirst, deparse_expr_cxt::params_list, Param::paramtype, Param::paramtypmod, printRemoteParam(), and printRemotePlaceholder().

Referenced by deparseExpr().

deparseRangeTblRef()

static void deparseRangeTblRef ( StringInfo  buf, PlannerInfo *  root, RelOptInfo *  foreignrel, bool  make_subquery, Index  ignore_rel, List **  ignore_conds, List **  additional_conds, List **  params_list  )

static

Definition at line 2041 of file deparse.c.

{
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
 
    /* Should only be called in these cases. */
    Assert(IS_SIMPLE_REL(foreignrel) || IS_JOIN_REL(foreignrel));
 
    Assert(fpinfo->local_conds == NIL);
 
    /* If make_subquery is true, deparse the relation as a subquery. */
    if (make_subquery)
    {
        List       *retrieved_attrs;
        int         ncols;
 
        /*
         * The given relation shouldn't contain the target relation, because
         * this should only happen for input relations for a full join, and
         * such relations can never contain an UPDATE/DELETE target.
         */
        Assert(ignore_rel == 0 ||
               !bms_is_member(ignore_rel, foreignrel->relids));
 
        /* Deparse the subquery representing the relation. */
        appendStringInfoChar(buf, '(');
        deparseSelectStmtForRel(buf, root, foreignrel, NIL,
                                fpinfo->remote_conds, NIL,
                                false, false, true,
                                &retrieved_attrs, params_list);
        appendStringInfoChar(buf, ')');
 
        /* Append the relation alias. */
        appendStringInfo(buf, " %s%d", SUBQUERY_REL_ALIAS_PREFIX,
                         fpinfo->relation_index);
 
        /*
         * Append the column aliases if needed.  Note that the subquery emits
         * expressions specified in the relation's reltarget (see
         * deparseSubqueryTargetList).
         */
        ncols = list_length(foreignrel->reltarget->exprs);
        if (ncols > 0)
        {
            int         i;
 
            appendStringInfoChar(buf, '(');
            for (i = 1; i <= ncols; i++)
            {
                if (i > 1)
                    appendStringInfoString(buf, ", ");
 
                appendStringInfo(buf, "%s%d", SUBQUERY_COL_ALIAS_PREFIX, i);
            }
            appendStringInfoChar(buf, ')');
        }
    }
    else
        deparseFromExprForRel(buf, root, foreignrel, true, ignore_rel,
                              ignore_conds, additional_conds,
                              params_list);
}

References appendStringInfo(), appendStringInfoChar(), appendStringInfoString(), Assert(), bms_is_member(), buf, deparseFromExprForRel(), deparseSelectStmtForRel(), PathTarget::exprs, i, IS_JOIN_REL, IS_SIMPLE_REL, list_length(), PgFdwRelationInfo::local_conds, NIL, PgFdwRelationInfo::relation_index, RelOptInfo::relids, RelOptInfo::reltarget, PgFdwRelationInfo::remote_conds, root, SUBQUERY_COL_ALIAS_PREFIX, and SUBQUERY_REL_ALIAS_PREFIX.

Referenced by deparseFromExprForRel().

deparseRelabelType()

static void deparseRelabelType ( RelabelType *  node, deparse_expr_cxt *  context  )

static

Definition at line 3533 of file deparse.c.

{
    deparseExpr(node->arg, context);
    if (node->relabelformat != COERCE_IMPLICIT_CAST)
        appendStringInfo(context->buf, "::%s",
                         deparse_type_name(node->resulttype,
                                           node->resulttypmod));
}

References appendStringInfo(), RelabelType::arg, deparse_expr_cxt::buf, COERCE_IMPLICIT_CAST, deparse_type_name(), deparseExpr(), and RelabelType::resulttype.

Referenced by deparseExpr().

deparseRelation()

static void deparseRelation ( StringInfo  buf, Relation  rel  )

static

Definition at line 2842 of file deparse.c.

{
    ForeignTable *table;
    const char *nspname = NULL;
    const char *relname = NULL;
    ListCell   *lc;
 
    /* obtain additional catalog information. */
    table = GetForeignTable(RelationGetRelid(rel));
 
    /*
     * Use value of FDW options if any, instead of the name of object itself.
     */
    foreach(lc, table->options)
    {
        DefElem    *def = (DefElem *) lfirst(lc);
 
        if (strcmp(def->defname, "schema_name") == 0)
            nspname = defGetString(def);
        else if (strcmp(def->defname, "table_name") == 0)
            relname = defGetString(def);
    }
 
    /*
     * Note: we could skip printing the schema name if it's pg_catalog, but
     * that doesn't seem worth the trouble.
     */
    if (nspname == NULL)
        nspname = get_namespace_name(RelationGetNamespace(rel));
    if (relname == NULL)
        relname = RelationGetRelationName(rel);
 
    appendStringInfo(buf, "%s.%s",
                     quote_identifier(nspname), quote_identifier(relname));
}

References appendStringInfo(), buf, defGetString(), DefElem::defname, get_namespace_name(), GetForeignTable(), lfirst, quote_identifier(), RelationGetNamespace, RelationGetRelationName, RelationGetRelid, relname, and table.

Referenced by deparseAnalyzeInfoSql(), deparseAnalyzeSizeSql(), deparseAnalyzeSql(), deparseDeleteSql(), deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseFromExprForRel(), deparseInsertSql(), deparseTruncateSql(), and deparseUpdateSql().

deparseReturningList()

static void deparseReturningList ( StringInfo  buf, RangeTblEntry *  rte, Index  rtindex, Relation  rel, bool  trig_after_row, List *  withCheckOptionList, List *  returningList, List **  retrieved_attrs  )

static

Definition at line 2475 of file deparse.c.

{
    Bitmapset  *attrs_used = NULL;
 
    if (trig_after_row)
    {
        /* whole-row reference acquires all non-system columns */
        attrs_used =
            bms_make_singleton(0 - FirstLowInvalidHeapAttributeNumber);
    }
 
    if (withCheckOptionList != NIL)
    {
        /*
         * We need the attrs, non-system and system, mentioned in the local
         * query's WITH CHECK OPTION list.
         *
         * Note: we do this to ensure that WCO constraints will be evaluated
         * on the data actually inserted/updated on the remote side, which
         * might differ from the data supplied by the core code, for example
         * as a result of remote triggers.
         */
        pull_varattnos((Node *) withCheckOptionList, rtindex,
                       &attrs_used);
    }
 
    if (returningList != NIL)
    {
        /*
         * We need the attrs, non-system and system, mentioned in the local
         * query's RETURNING list.
         */
        pull_varattnos((Node *) returningList, rtindex,
                       &attrs_used);
    }
 
    if (attrs_used != NULL)
        deparseTargetList(buf, rte, rtindex, rel, true, attrs_used, false,
                          retrieved_attrs);
    else
        *retrieved_attrs = NIL;
}

References bms_make_singleton(), buf, deparseTargetList(), FirstLowInvalidHeapAttributeNumber, NIL, and pull_varattnos().

Referenced by deparseDeleteSql(), deparseDirectDeleteSql(), deparseDirectUpdateSql(), deparseInsertSql(), and deparseUpdateSql().

deparseScalarArrayOpExpr()

static void deparseScalarArrayOpExpr ( ScalarArrayOpExpr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3488 of file deparse.c.

{
    StringInfo  buf = context->buf;
    HeapTuple   tuple;
    Form_pg_operator form;
    Expr       *arg1;
    Expr       *arg2;
 
    /* Retrieve information about the operator from system catalog. */
    tuple = SearchSysCache1(OPEROID, ObjectIdGetDatum(node->opno));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for operator %u", node->opno);
    form = (Form_pg_operator) GETSTRUCT(tuple);
 
    /* Sanity check. */
    Assert(list_length(node->args) == 2);
 
    /* Always parenthesize the expression. */
    appendStringInfoChar(buf, '(');
 
    /* Deparse left operand. */
    arg1 = linitial(node->args);
    deparseExpr(arg1, context);
    appendStringInfoChar(buf, ' ');
 
    /* Deparse operator name plus decoration. */
    deparseOperatorName(buf, form);
    appendStringInfo(buf, " %s (", node->useOr ? "ANY" : "ALL");
 
    /* Deparse right operand. */
    arg2 = lsecond(node->args);
    deparseExpr(arg2, context);
 
    appendStringInfoChar(buf, ')');
 
    /* Always parenthesize the expression. */
    appendStringInfoChar(buf, ')');
 
    ReleaseSysCache(tuple);
}

References appendStringInfo(), appendStringInfoChar(), ScalarArrayOpExpr::args, Assert(), deparse_expr_cxt::buf, buf, deparseExpr(), deparseOperatorName(), elog, ERROR, GETSTRUCT(), HeapTupleIsValid, linitial, list_length(), lsecond, ObjectIdGetDatum(), ScalarArrayOpExpr::opno, ReleaseSysCache(), SearchSysCache1(), and ScalarArrayOpExpr::useOr.

Referenced by deparseExpr().

deparseSelectSql()

static void deparseSelectSql ( List *  tlist, bool  is_subquery, List **  retrieved_attrs, deparse_expr_cxt *  context  )

static

Definition at line 1348 of file deparse.c.

{
    StringInfo  buf = context->buf;
    RelOptInfo *foreignrel = context->foreignrel;
    PlannerInfo *root = context->root;
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
 
    /*
     * Construct SELECT list
     */
    appendStringInfoString(buf, "SELECT ");
 
    if (is_subquery)
    {
        /*
         * For a relation that is deparsed as a subquery, emit expressions
         * specified in the relation's reltarget.  Note that since this is for
         * the subquery, no need to care about *retrieved_attrs.
         */
        deparseSubqueryTargetList(context);
    }
    else if (IS_JOIN_REL(foreignrel) || IS_UPPER_REL(foreignrel))
    {
        /*
         * For a join or upper relation the input tlist gives the list of
         * columns required to be fetched from the foreign server.
         */
        deparseExplicitTargetList(tlist, false, retrieved_attrs, context);
    }
    else
    {
        /*
         * For a base relation fpinfo->attrs_used gives the list of columns
         * required to be fetched from the foreign server.
         */
        RangeTblEntry *rte = planner_rt_fetch(foreignrel->relid, root);
 
        /*
         * Core code already has some lock on each rel being planned, so we
         * can use NoLock here.
         */
        Relation    rel = table_open(rte->relid, NoLock);
 
        deparseTargetList(buf, rte, foreignrel->relid, rel, false,
                          fpinfo->attrs_used, false, retrieved_attrs);
        table_close(rel, NoLock);
    }
}

References appendStringInfoString(), PgFdwRelationInfo::attrs_used, deparse_expr_cxt::buf, buf, deparseExplicitTargetList(), deparseSubqueryTargetList(), deparseTargetList(), deparse_expr_cxt::foreignrel, IS_JOIN_REL, IS_UPPER_REL, NoLock, planner_rt_fetch, RelOptInfo::relid, deparse_expr_cxt::root, root, table_close(), and table_open().

Referenced by deparseSelectStmtForRel().

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 1266 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(), deparse_expr_cxt::buf, buf, deparseFromExpr(), deparseLockingClause(), deparseSelectSql(), deparse_expr_cxt::foreignrel, IS_JOIN_REL, IS_SIMPLE_REL, IS_UPPER_REL, PgFdwRelationInfo::outerrel, deparse_expr_cxt::params_list, PgFdwRelationInfo::remote_conds, deparse_expr_cxt::root, root, and deparse_expr_cxt::scanrel.

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

deparseSortGroupClause()

static Node * deparseSortGroupClause ( Index  ref, List *  tlist, bool  force_colno, deparse_expr_cxt *  context  )

static

Definition at line 4121 of file deparse.c.

{
    StringInfo  buf = context->buf;
    TargetEntry *tle;
    Expr       *expr;
 
    tle = get_sortgroupref_tle(ref, tlist);
    expr = tle->expr;
 
    if (force_colno)
    {
        /* Use column-number form when requested by caller. */
        Assert(!tle->resjunk);
        appendStringInfo(buf, "%d", tle->resno);
    }
    else if (expr && IsA(expr, Const))
    {
        /*
         * Force a typecast here so that we don't emit something like "GROUP
         * BY 2", which will be misconstrued as a column position rather than
         * a constant.
         */
        deparseConst((Const *) expr, context, 1);
    }
    else if (!expr || IsA(expr, Var))
        deparseExpr(expr, context);
    else
    {
        /* Always parenthesize the expression. */
        appendStringInfoChar(buf, '(');
        deparseExpr(expr, context);
        appendStringInfoChar(buf, ')');
    }
 
    return (Node *) expr;
}

References appendStringInfo(), appendStringInfoChar(), Assert(), deparse_expr_cxt::buf, buf, deparseConst(), deparseExpr(), TargetEntry::expr, get_sortgroupref_tle(), IsA, and TargetEntry::resno.

Referenced by appendAggOrderBy(), and appendGroupByClause().

deparseStringLiteral()

void deparseStringLiteral	(	StringInfo	buf,
		const char *	val
	)

Definition at line 2882 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().

deparseSubqueryTargetList()

static void deparseSubqueryTargetList ( deparse_expr_cxt *  context )

static

Definition at line 1750 of file deparse.c.

{
    StringInfo  buf = context->buf;
    RelOptInfo *foreignrel = context->foreignrel;
    bool        first;
    ListCell   *lc;
 
    /* Should only be called in these cases. */
    Assert(IS_SIMPLE_REL(foreignrel) || IS_JOIN_REL(foreignrel));
 
    first = true;
    foreach(lc, foreignrel->reltarget->exprs)
    {
        Node       *node = (Node *) lfirst(lc);
 
        if (!first)
            appendStringInfoString(buf, ", ");
        first = false;
 
        deparseExpr((Expr *) node, context);
    }
 
    /* Don't generate bad syntax if no expressions */
    if (first)
        appendStringInfoString(buf, "NULL");
}

References appendStringInfoString(), Assert(), deparse_expr_cxt::buf, buf, deparseExpr(), PathTarget::exprs, deparse_expr_cxt::foreignrel, IS_JOIN_REL, IS_SIMPLE_REL, lfirst, and RelOptInfo::reltarget.

Referenced by deparseSelectSql().

deparseSubscriptingRef()

static void deparseSubscriptingRef ( SubscriptingRef *  node, deparse_expr_cxt *  context  )

static

Definition at line 3203 of file deparse.c.

{
    StringInfo  buf = context->buf;
    ListCell   *lowlist_item;
    ListCell   *uplist_item;
 
    /* Always parenthesize the expression. */
    appendStringInfoChar(buf, '(');
 
    /*
     * Deparse referenced array expression first.  If that expression includes
     * a cast, we have to parenthesize to prevent the array subscript from
     * being taken as typename decoration.  We can avoid that in the typical
     * case of subscripting a Var, but otherwise do it.
     */
    if (IsA(node->refexpr, Var))
        deparseExpr(node->refexpr, context);
    else
    {
        appendStringInfoChar(buf, '(');
        deparseExpr(node->refexpr, context);
        appendStringInfoChar(buf, ')');
    }
 
    /* Deparse subscript expressions. */
    lowlist_item = list_head(node->reflowerindexpr);    /* could be NULL */
    foreach(uplist_item, node->refupperindexpr)
    {
        appendStringInfoChar(buf, '[');
        if (lowlist_item)
        {
            deparseExpr(lfirst(lowlist_item), context);
            appendStringInfoChar(buf, ':');
            lowlist_item = lnext(node->reflowerindexpr, lowlist_item);
        }
        deparseExpr(lfirst(uplist_item), context);
        appendStringInfoChar(buf, ']');
    }
 
    appendStringInfoChar(buf, ')');
}

References appendStringInfoChar(), deparse_expr_cxt::buf, buf, deparseExpr(), IsA, lfirst, list_head(), lnext(), SubscriptingRef::refexpr, SubscriptingRef::reflowerindexpr, and SubscriptingRef::refupperindexpr.

Referenced by deparseExpr().

deparseTargetList()

static void deparseTargetList ( StringInfo  buf, RangeTblEntry *  rte, Index  rtindex, Relation  rel, bool  is_returning, Bitmapset *  attrs_used, bool  qualify_col, List **  retrieved_attrs  )

static

Definition at line 1438 of file deparse.c.

{
    TupleDesc   tupdesc = RelationGetDescr(rel);
    bool        have_wholerow;
    bool        first;
    int         i;
 
    *retrieved_attrs = NIL;
 
    /* If there's a whole-row reference, we'll need all the columns. */
    have_wholerow = bms_is_member(0 - FirstLowInvalidHeapAttributeNumber,
                                  attrs_used);
 
    first = true;
    for (i = 1; i <= tupdesc->natts; i++)
    {
        Form_pg_attribute attr = TupleDescAttr(tupdesc, i - 1);
 
        /* Ignore dropped attributes. */
        if (attr->attisdropped)
            continue;
 
        if (have_wholerow ||
            bms_is_member(i - FirstLowInvalidHeapAttributeNumber,
                          attrs_used))
        {
            if (!first)
                appendStringInfoString(buf, ", ");
            else if (is_returning)
                appendStringInfoString(buf, " RETURNING ");
            first = false;
 
            deparseColumnRef(buf, rtindex, i, rte, qualify_col);
 
            *retrieved_attrs = lappend_int(*retrieved_attrs, i);
        }
    }
 
    /*
     * Add ctid if needed.  We currently don't support retrieving any other
     * system columns.
     */
    if (bms_is_member(SelfItemPointerAttributeNumber - FirstLowInvalidHeapAttributeNumber,
                      attrs_used))
    {
        if (!first)
            appendStringInfoString(buf, ", ");
        else if (is_returning)
            appendStringInfoString(buf, " RETURNING ");
        first = false;
 
        if (qualify_col)
            ADD_REL_QUALIFIER(buf, rtindex);
        appendStringInfoString(buf, "ctid");
 
        *retrieved_attrs = lappend_int(*retrieved_attrs,
                                       SelfItemPointerAttributeNumber);
    }
 
    /* Don't generate bad syntax if no undropped columns */
    if (first && !is_returning)
        appendStringInfoString(buf, "NULL");
}

References ADD_REL_QUALIFIER, appendStringInfoString(), bms_is_member(), buf, deparseColumnRef(), FirstLowInvalidHeapAttributeNumber, i, lappend_int(), TupleDescData::natts, NIL, RelationGetDescr, SelfItemPointerAttributeNumber, and TupleDescAttr().

Referenced by deparseColumnRef(), deparseReturningList(), and deparseSelectSql().

deparseTruncateSql()

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

Definition at line 2679 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 2249 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().

deparseVar()

static void deparseVar ( Var *  node, deparse_expr_cxt *  context  )

static

Definition at line 2985 of file deparse.c.

{
    Relids      relids = context->scanrel->relids;
    int         relno;
    int         colno;
 
    /* Qualify columns when multiple relations are involved. */
    bool        qualify_col = (bms_membership(relids) == BMS_MULTIPLE);
 
    /*
     * If the Var belongs to the foreign relation that is deparsed as a
     * subquery, use the relation and column alias to the Var provided by the
     * subquery, instead of the remote name.
     */
    if (is_subquery_var(node, context->scanrel, &relno, &colno))
    {
        appendStringInfo(context->buf, "%s%d.%s%d",
                         SUBQUERY_REL_ALIAS_PREFIX, relno,
                         SUBQUERY_COL_ALIAS_PREFIX, colno);
        return;
    }
 
    if (bms_is_member(node->varno, relids) && node->varlevelsup == 0)
        deparseColumnRef(context->buf, node->varno, node->varattno,
                         planner_rt_fetch(node->varno, context->root),
                         qualify_col);
    else
    {
        /* Treat like a Param */
        if (context->params_list)
        {
            int         pindex = 0;
            ListCell   *lc;
 
            /* find its index in params_list */
            foreach(lc, *context->params_list)
            {
                pindex++;
                if (equal(node, (Node *) lfirst(lc)))
                    break;
            }
            if (lc == NULL)
            {
                /* not in list, so add it */
                pindex++;
                *context->params_list = lappend(*context->params_list, node);
            }
 
            printRemoteParam(pindex, node->vartype, node->vartypmod, context);
        }
        else
        {
            printRemotePlaceholder(node->vartype, node->vartypmod, context);
        }
    }
}

References appendStringInfo(), bms_is_member(), bms_membership(), BMS_MULTIPLE, deparse_expr_cxt::buf, deparseColumnRef(), equal(), is_subquery_var(), lappend(), lfirst, deparse_expr_cxt::params_list, planner_rt_fetch, printRemoteParam(), printRemotePlaceholder(), RelOptInfo::relids, deparse_expr_cxt::root, deparse_expr_cxt::scanrel, SUBQUERY_COL_ALIAS_PREFIX, SUBQUERY_REL_ALIAS_PREFIX, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by deparseExpr().

foreign_expr_walker()

static bool foreign_expr_walker ( Node *  node, foreign_glob_cxt *  glob_cxt, foreign_loc_cxt *  outer_cxt, foreign_loc_cxt *  case_arg_cxt  )

static

Definition at line 312 of file deparse.c.

{
    bool        check_type = true;
    PgFdwRelationInfo *fpinfo;
    foreign_loc_cxt inner_cxt;
    Oid         collation;
    FDWCollateState state;
 
    /* Need do nothing for empty subexpressions */
    if (node == NULL)
        return true;
 
    /* May need server info from baserel's fdw_private struct */
    fpinfo = (PgFdwRelationInfo *) (glob_cxt->foreignrel->fdw_private);
 
    /* Set up inner_cxt for possible recursion to child nodes */
    inner_cxt.collation = InvalidOid;
    inner_cxt.state = FDW_COLLATE_NONE;
 
    switch (nodeTag(node))
    {
        case T_Var:
            {
                Var        *var = (Var *) node;
 
                /*
                 * If the Var is from the foreign table, we consider its
                 * collation (if any) safe to use.  If it is from another
                 * table, we treat its collation the same way as we would a
                 * Param's collation, ie it's not safe for it to have a
                 * non-default collation.
                 */
                if (bms_is_member(var->varno, glob_cxt->relids) &&
                    var->varlevelsup == 0)
                {
                    /* Var belongs to foreign table */
 
                    /*
                     * System columns other than ctid should not be sent to
                     * the remote, since we don't make any effort to ensure
                     * that local and remote values match (tableoid, in
                     * particular, almost certainly doesn't match).
                     */
                    if (var->varattno < 0 &&
                        var->varattno != SelfItemPointerAttributeNumber)
                        return false;
 
                    /* Else check the collation */
                    collation = var->varcollid;
                    state = OidIsValid(collation) ? FDW_COLLATE_SAFE : FDW_COLLATE_NONE;
                }
                else
                {
                    /* Var belongs to some other table */
                    collation = var->varcollid;
                    if (collation == InvalidOid ||
                        collation == DEFAULT_COLLATION_OID)
                    {
                        /*
                         * It's noncollatable, or it's safe to combine with a
                         * collatable foreign Var, so set state to NONE.
                         */
                        state = FDW_COLLATE_NONE;
                    }
                    else
                    {
                        /*
                         * Do not fail right away, since the Var might appear
                         * in a collation-insensitive context.
                         */
                        state = FDW_COLLATE_UNSAFE;
                    }
                }
            }
            break;
        case T_Const:
            {
                Const      *c = (Const *) node;
 
                /*
                 * Constants of regproc and related types can't be shipped
                 * unless the referenced object is shippable.  But NULL's ok.
                 * (See also the related code in dependency.c.)
                 */
                if (!c->constisnull)
                {
                    switch (c->consttype)
                    {
                        case REGPROCOID:
                        case REGPROCEDUREOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              ProcedureRelationId, fpinfo))
                                return false;
                            break;
                        case REGOPEROID:
                        case REGOPERATOROID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              OperatorRelationId, fpinfo))
                                return false;
                            break;
                        case REGCLASSOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              RelationRelationId, fpinfo))
                                return false;
                            break;
                        case REGTYPEOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              TypeRelationId, fpinfo))
                                return false;
                            break;
                        case REGCOLLATIONOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              CollationRelationId, fpinfo))
                                return false;
                            break;
                        case REGCONFIGOID:
 
                            /*
                             * For text search objects only, we weaken the
                             * normal shippability criterion to allow all OIDs
                             * below FirstNormalObjectId.  Without this, none
                             * of the initdb-installed TS configurations would
                             * be shippable, which would be quite annoying.
                             */
                            if (DatumGetObjectId(c->constvalue) >= FirstNormalObjectId &&
                                !is_shippable(DatumGetObjectId(c->constvalue),
                                              TSConfigRelationId, fpinfo))
                                return false;
                            break;
                        case REGDICTIONARYOID:
                            if (DatumGetObjectId(c->constvalue) >= FirstNormalObjectId &&
                                !is_shippable(DatumGetObjectId(c->constvalue),
                                              TSDictionaryRelationId, fpinfo))
                                return false;
                            break;
                        case REGNAMESPACEOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              NamespaceRelationId, fpinfo))
                                return false;
                            break;
                        case REGROLEOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              AuthIdRelationId, fpinfo))
                                return false;
                            break;
                        case REGDATABASEOID:
                            if (!is_shippable(DatumGetObjectId(c->constvalue),
                                              DatabaseRelationId, fpinfo))
                                return false;
                            break;
                    }
                }
 
                /*
                 * If the constant has nondefault collation, either it's of a
                 * non-builtin type, or it reflects folding of a CollateExpr.
                 * It's unsafe to send to the remote unless it's used in a
                 * non-collation-sensitive context.
                 */
                collation = c->constcollid;
                if (collation == InvalidOid ||
                    collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_Param:
            {
                Param      *p = (Param *) node;
 
                /*
                 * If it's a MULTIEXPR Param, punt.  We can't tell from here
                 * whether the referenced sublink/subplan contains any remote
                 * Vars; if it does, handling that is too complicated to
                 * consider supporting at present.  Fortunately, MULTIEXPR
                 * Params are not reduced to plain PARAM_EXEC until the end of
                 * planning, so we can easily detect this case.  (Normal
                 * PARAM_EXEC Params are safe to ship because their values
                 * come from somewhere else in the plan tree; but a MULTIEXPR
                 * references a sub-select elsewhere in the same targetlist,
                 * so we'd be on the hook to evaluate it somehow if we wanted
                 * to handle such cases as direct foreign updates.)
                 */
                if (p->paramkind == PARAM_MULTIEXPR)
                    return false;
 
                /*
                 * Collation rule is same as for Consts and non-foreign Vars.
                 */
                collation = p->paramcollid;
                if (collation == InvalidOid ||
                    collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_SubscriptingRef:
            {
                SubscriptingRef *sr = (SubscriptingRef *) node;
 
                /* Assignment should not be in restrictions. */
                if (sr->refassgnexpr != NULL)
                    return false;
 
                /*
                 * Recurse into the remaining subexpressions.  The container
                 * subscripts will not affect collation of the SubscriptingRef
                 * result, so do those first and reset inner_cxt afterwards.
                 */
                if (!foreign_expr_walker((Node *) sr->refupperindexpr,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
                inner_cxt.collation = InvalidOid;
                inner_cxt.state = FDW_COLLATE_NONE;
                if (!foreign_expr_walker((Node *) sr->reflowerindexpr,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
                inner_cxt.collation = InvalidOid;
                inner_cxt.state = FDW_COLLATE_NONE;
                if (!foreign_expr_walker((Node *) sr->refexpr,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * Container subscripting typically yields same collation as
                 * refexpr's, but in case it doesn't, use same logic as for
                 * function nodes.
                 */
                collation = sr->refcollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_FuncExpr:
            {
                FuncExpr   *fe = (FuncExpr *) node;
 
                /*
                 * If function used by the expression is not shippable, it
                 * can't be sent to remote because it might have incompatible
                 * semantics on remote side.
                 */
                if (!is_shippable(fe->funcid, ProcedureRelationId, fpinfo))
                    return false;
 
                /*
                 * Recurse to input subexpressions.
                 */
                if (!foreign_expr_walker((Node *) fe->args,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * If function's input collation is not derived from a foreign
                 * Var, it can't be sent to remote.
                 */
                if (fe->inputcollid == InvalidOid)
                     /* OK, inputs are all noncollatable */ ;
                else if (inner_cxt.state != FDW_COLLATE_SAFE ||
                         fe->inputcollid != inner_cxt.collation)
                    return false;
 
                /*
                 * Detect whether node is introducing a collation not derived
                 * from a foreign Var.  (If so, we just mark it unsafe for now
                 * rather than immediately returning false, since the parent
                 * node might not care.)
                 */
                collation = fe->funccollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_OpExpr:
        case T_DistinctExpr:    /* struct-equivalent to OpExpr */
            {
                OpExpr     *oe = (OpExpr *) node;
 
                /*
                 * Similarly, only shippable operators can be sent to remote.
                 * (If the operator is shippable, we assume its underlying
                 * function is too.)
                 */
                if (!is_shippable(oe->opno, OperatorRelationId, fpinfo))
                    return false;
 
                /*
                 * Recurse to input subexpressions.
                 */
                if (!foreign_expr_walker((Node *) oe->args,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * If operator's input collation is not derived from a foreign
                 * Var, it can't be sent to remote.
                 */
                if (oe->inputcollid == InvalidOid)
                     /* OK, inputs are all noncollatable */ ;
                else if (inner_cxt.state != FDW_COLLATE_SAFE ||
                         oe->inputcollid != inner_cxt.collation)
                    return false;
 
                /* Result-collation handling is same as for functions */
                collation = oe->opcollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_ScalarArrayOpExpr:
            {
                ScalarArrayOpExpr *oe = (ScalarArrayOpExpr *) node;
 
                /*
                 * Again, only shippable operators can be sent to remote.
                 */
                if (!is_shippable(oe->opno, OperatorRelationId, fpinfo))
                    return false;
 
                /*
                 * Recurse to input subexpressions.
                 */
                if (!foreign_expr_walker((Node *) oe->args,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * If operator's input collation is not derived from a foreign
                 * Var, it can't be sent to remote.
                 */
                if (oe->inputcollid == InvalidOid)
                     /* OK, inputs are all noncollatable */ ;
                else if (inner_cxt.state != FDW_COLLATE_SAFE ||
                         oe->inputcollid != inner_cxt.collation)
                    return false;
 
                /* Output is always boolean and so noncollatable. */
                collation = InvalidOid;
                state = FDW_COLLATE_NONE;
            }
            break;
        case T_RelabelType:
            {
                RelabelType *r = (RelabelType *) node;
 
                /*
                 * Recurse to input subexpression.
                 */
                if (!foreign_expr_walker((Node *) r->arg,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * RelabelType must not introduce a collation not derived from
                 * an input foreign Var (same logic as for a real function).
                 */
                collation = r->resultcollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_ArrayCoerceExpr:
            {
                ArrayCoerceExpr *e = (ArrayCoerceExpr *) node;
 
                /*
                 * Recurse to input subexpression.
                 */
                if (!foreign_expr_walker((Node *) e->arg,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * T_ArrayCoerceExpr must not introduce a collation not
                 * derived from an input foreign Var (same logic as for a
                 * function).
                 */
                collation = e->resultcollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_BoolExpr:
            {
                BoolExpr   *b = (BoolExpr *) node;
 
                /*
                 * Recurse to input subexpressions.
                 */
                if (!foreign_expr_walker((Node *) b->args,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /* Output is always boolean and so noncollatable. */
                collation = InvalidOid;
                state = FDW_COLLATE_NONE;
            }
            break;
        case T_NullTest:
            {
                NullTest   *nt = (NullTest *) node;
 
                /*
                 * Recurse to input subexpressions.
                 */
                if (!foreign_expr_walker((Node *) nt->arg,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /* Output is always boolean and so noncollatable. */
                collation = InvalidOid;
                state = FDW_COLLATE_NONE;
            }
            break;
        case T_CaseExpr:
            {
                CaseExpr   *ce = (CaseExpr *) node;
                foreign_loc_cxt arg_cxt;
                foreign_loc_cxt tmp_cxt;
                ListCell   *lc;
 
                /*
                 * Recurse to CASE's arg expression, if any.  Its collation
                 * has to be saved aside for use while examining CaseTestExprs
                 * within the WHEN expressions.
                 */
                arg_cxt.collation = InvalidOid;
                arg_cxt.state = FDW_COLLATE_NONE;
                if (ce->arg)
                {
                    if (!foreign_expr_walker((Node *) ce->arg,
                                             glob_cxt, &arg_cxt, case_arg_cxt))
                        return false;
                }
 
                /* Examine the CaseWhen subexpressions. */
                foreach(lc, ce->args)
                {
                    CaseWhen   *cw = lfirst_node(CaseWhen, lc);
 
                    if (ce->arg)
                    {
                        /*
                         * In a CASE-with-arg, the parser should have produced
                         * WHEN clauses of the form "CaseTestExpr = RHS",
                         * possibly with an implicit coercion inserted above
                         * the CaseTestExpr.  However in an expression that's
                         * been through the optimizer, the WHEN clause could
                         * be almost anything (since the equality operator
                         * could have been expanded into an inline function).
                         * In such cases forbid pushdown, because
                         * deparseCaseExpr can't handle it.
                         */
                        Node       *whenExpr = (Node *) cw->expr;
                        List       *opArgs;
 
                        if (!IsA(whenExpr, OpExpr))
                            return false;
 
                        opArgs = ((OpExpr *) whenExpr)->args;
                        if (list_length(opArgs) != 2 ||
                            !IsA(strip_implicit_coercions(linitial(opArgs)),
                                 CaseTestExpr))
                            return false;
                    }
 
                    /*
                     * Recurse to WHEN expression, passing down the arg info.
                     * Its collation doesn't affect the result (really, it
                     * should be boolean and thus not have a collation).
                     */
                    tmp_cxt.collation = InvalidOid;
                    tmp_cxt.state = FDW_COLLATE_NONE;
                    if (!foreign_expr_walker((Node *) cw->expr,
                                             glob_cxt, &tmp_cxt, &arg_cxt))
                        return false;
 
                    /* Recurse to THEN expression. */
                    if (!foreign_expr_walker((Node *) cw->result,
                                             glob_cxt, &inner_cxt, case_arg_cxt))
                        return false;
                }
 
                /* Recurse to ELSE expression. */
                if (!foreign_expr_walker((Node *) ce->defresult,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * Detect whether node is introducing a collation not derived
                 * from a foreign Var.  (If so, we just mark it unsafe for now
                 * rather than immediately returning false, since the parent
                 * node might not care.)  This is the same as for function
                 * nodes, except that the input collation is derived from only
                 * the THEN and ELSE subexpressions.
                 */
                collation = ce->casecollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_CaseTestExpr:
            {
                CaseTestExpr *c = (CaseTestExpr *) node;
 
                /* Punt if we seem not to be inside a CASE arg WHEN. */
                if (!case_arg_cxt)
                    return false;
 
                /*
                 * Otherwise, any nondefault collation attached to the
                 * CaseTestExpr node must be derived from foreign Var(s) in
                 * the CASE arg.
                 */
                collation = c->collation;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (case_arg_cxt->state == FDW_COLLATE_SAFE &&
                         collation == case_arg_cxt->collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_ArrayExpr:
            {
                ArrayExpr  *a = (ArrayExpr *) node;
 
                /*
                 * Recurse to input subexpressions.
                 */
                if (!foreign_expr_walker((Node *) a->elements,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * ArrayExpr must not introduce a collation not derived from
                 * an input foreign Var (same logic as for a function).
                 */
                collation = a->array_collid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        case T_List:
            {
                List       *l = (List *) node;
                ListCell   *lc;
 
                /*
                 * Recurse to component subexpressions.
                 */
                foreach(lc, l)
                {
                    if (!foreign_expr_walker((Node *) lfirst(lc),
                                             glob_cxt, &inner_cxt, case_arg_cxt))
                        return false;
                }
 
                /*
                 * When processing a list, collation state just bubbles up
                 * from the list elements.
                 */
                collation = inner_cxt.collation;
                state = inner_cxt.state;
 
                /* Don't apply exprType() to the list. */
                check_type = false;
            }
            break;
        case T_Aggref:
            {
                Aggref     *agg = (Aggref *) node;
                ListCell   *lc;
 
                /* Not safe to pushdown when not in grouping context */
                if (!IS_UPPER_REL(glob_cxt->foreignrel))
                    return false;
 
                /* Only non-split aggregates are pushable. */
                if (agg->aggsplit != AGGSPLIT_SIMPLE)
                    return false;
 
                /* As usual, it must be shippable. */
                if (!is_shippable(agg->aggfnoid, ProcedureRelationId, fpinfo))
                    return false;
 
                /*
                 * Recurse to input args. aggdirectargs, aggorder and
                 * aggdistinct are all present in args, so no need to check
                 * their shippability explicitly.
                 */
                foreach(lc, agg->args)
                {
                    Node       *n = (Node *) lfirst(lc);
 
                    /* If TargetEntry, extract the expression from it */
                    if (IsA(n, TargetEntry))
                    {
                        TargetEntry *tle = (TargetEntry *) n;
 
                        n = (Node *) tle->expr;
                    }
 
                    if (!foreign_expr_walker(n,
                                             glob_cxt, &inner_cxt, case_arg_cxt))
                        return false;
                }
 
                /*
                 * For aggorder elements, check whether the sort operator, if
                 * specified, is shippable or not.
                 */
                if (agg->aggorder)
                {
                    foreach(lc, agg->aggorder)
                    {
                        SortGroupClause *srt = (SortGroupClause *) lfirst(lc);
                        Oid         sortcoltype;
                        TypeCacheEntry *typentry;
                        TargetEntry *tle;
 
                        tle = get_sortgroupref_tle(srt->tleSortGroupRef,
                                                   agg->args);
                        sortcoltype = exprType((Node *) tle->expr);
                        typentry = lookup_type_cache(sortcoltype,
                                                     TYPECACHE_LT_OPR | TYPECACHE_GT_OPR);
                        /* Check shippability of non-default sort operator. */
                        if (srt->sortop != typentry->lt_opr &&
                            srt->sortop != typentry->gt_opr &&
                            !is_shippable(srt->sortop, OperatorRelationId,
                                          fpinfo))
                            return false;
                    }
                }
 
                /* Check aggregate filter */
                if (!foreign_expr_walker((Node *) agg->aggfilter,
                                         glob_cxt, &inner_cxt, case_arg_cxt))
                    return false;
 
                /*
                 * If aggregate's input collation is not derived from a
                 * foreign Var, it can't be sent to remote.
                 */
                if (agg->inputcollid == InvalidOid)
                     /* OK, inputs are all noncollatable */ ;
                else if (inner_cxt.state != FDW_COLLATE_SAFE ||
                         agg->inputcollid != inner_cxt.collation)
                    return false;
 
                /*
                 * Detect whether node is introducing a collation not derived
                 * from a foreign Var.  (If so, we just mark it unsafe for now
                 * rather than immediately returning false, since the parent
                 * node might not care.)
                 */
                collation = agg->aggcollid;
                if (collation == InvalidOid)
                    state = FDW_COLLATE_NONE;
                else if (inner_cxt.state == FDW_COLLATE_SAFE &&
                         collation == inner_cxt.collation)
                    state = FDW_COLLATE_SAFE;
                else if (collation == DEFAULT_COLLATION_OID)
                    state = FDW_COLLATE_NONE;
                else
                    state = FDW_COLLATE_UNSAFE;
            }
            break;
        default:
 
            /*
             * If it's anything else, assume it's unsafe.  This list can be
             * expanded later, but don't forget to add deparse support below.
             */
            return false;
    }
 
    /*
     * If result type of given expression is not shippable, it can't be sent
     * to remote because it might have incompatible semantics on remote side.
     */
    if (check_type && !is_shippable(exprType(node), TypeRelationId, fpinfo))
        return false;
 
    /*
     * Now, merge my collation information into my parent's state.
     */
    if (state > outer_cxt->state)
    {
        /* Override previous parent state */
        outer_cxt->collation = collation;
        outer_cxt->state = state;
    }
    else if (state == outer_cxt->state)
    {
        /* Merge, or detect error if there's a collation conflict */
        switch (state)
        {
            case FDW_COLLATE_NONE:
                /* Nothing + nothing is still nothing */
                break;
            case FDW_COLLATE_SAFE:
                if (collation != outer_cxt->collation)
                {
                    /*
                     * Non-default collation always beats default.
                     */
                    if (outer_cxt->collation == DEFAULT_COLLATION_OID)
                    {
                        /* Override previous parent state */
                        outer_cxt->collation = collation;
                    }
                    else if (collation != DEFAULT_COLLATION_OID)
                    {
                        /*
                         * Conflict; show state as indeterminate.  We don't
                         * want to "return false" right away, since parent
                         * node might not care about collation.
                         */
                        outer_cxt->state = FDW_COLLATE_UNSAFE;
                    }
                }
                break;
            case FDW_COLLATE_UNSAFE:
                /* We're still conflicted ... */
                break;
        }
    }
 
    /* It looks OK */
    return true;
}

References a, Aggref::aggfilter, Aggref::aggfnoid, Aggref::aggorder, AGGSPLIT_SIMPLE, RelabelType::arg, CaseExpr::arg, NullTest::arg, Aggref::args, OpExpr::args, ScalarArrayOpExpr::args, CaseExpr::args, b, bms_is_member(), foreign_loc_cxt::collation, DatumGetObjectId(), CaseExpr::defresult, CaseWhen::expr, TargetEntry::expr, exprType(), FDW_COLLATE_NONE, FDW_COLLATE_SAFE, FDW_COLLATE_UNSAFE, fe(), FirstNormalObjectId, foreign_expr_walker(), foreign_glob_cxt::foreignrel, get_sortgroupref_tle(), TypeCacheEntry::gt_opr, if(), InvalidOid, is_shippable(), IS_UPPER_REL, IsA, lfirst, lfirst_node, linitial, list_length(), lookup_type_cache(), TypeCacheEntry::lt_opr, nodeTag, OidIsValid, OpExpr::opno, ScalarArrayOpExpr::opno, PARAM_MULTIEXPR, Param::paramcollid, Param::paramkind, SubscriptingRef::refassgnexpr, SubscriptingRef::refexpr, SubscriptingRef::reflowerindexpr, SubscriptingRef::refupperindexpr, foreign_glob_cxt::relids, CaseWhen::result, SelfItemPointerAttributeNumber, SortGroupClause::sortop, foreign_loc_cxt::state, strip_implicit_coercions(), SortGroupClause::tleSortGroupRef, TYPECACHE_GT_OPR, TYPECACHE_LT_OPR, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by foreign_expr_walker(), and is_foreign_expr().

get_jointype_name()

const char * get_jointype_name

(

JoinType

jointype

)

Definition at line 1674 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().

get_relation_column_alias_ids()

static void get_relation_column_alias_ids ( Var *  node, RelOptInfo *  foreignrel, int *  relno, int *  colno  )

static

Definition at line 4228 of file deparse.c.

{
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
    int         i;
    ListCell   *lc;
 
    /* Get the relation alias ID */
    *relno = fpinfo->relation_index;
 
    /* Get the column alias ID */
    i = 1;
    foreach(lc, foreignrel->reltarget->exprs)
    {
        Var        *tlvar = (Var *) lfirst(lc);
 
        /*
         * Match reltarget entries only on varno/varattno.  Ideally there
         * would be some cross-check on varnullingrels, but it's unclear what
         * to do exactly; we don't have enough context to know what that value
         * should be.
         */
        if (IsA(tlvar, Var) &&
            tlvar->varno == node->varno &&
            tlvar->varattno == node->varattno)
        {
            *colno = i;
            return;
        }
        i++;
    }
 
    /* Shouldn't get here */
    elog(ERROR, "unexpected expression in subquery output");
}

References elog, ERROR, PathTarget::exprs, i, IsA, lfirst, PgFdwRelationInfo::relation_index, RelOptInfo::reltarget, Var::varattno, and Var::varno.

Referenced by is_subquery_var().

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 1115 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 1156 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_subquery_var()

static bool is_subquery_var ( Var *  node, RelOptInfo *  foreignrel, int *  relno, int *  colno  )

static

Definition at line 4166 of file deparse.c.

{
    PgFdwRelationInfo *fpinfo = (PgFdwRelationInfo *) foreignrel->fdw_private;
    RelOptInfo *outerrel = fpinfo->outerrel;
    RelOptInfo *innerrel = fpinfo->innerrel;
 
    /* Should only be called in these cases. */
    Assert(IS_SIMPLE_REL(foreignrel) || IS_JOIN_REL(foreignrel));
 
    /*
     * If the given relation isn't a join relation, it doesn't have any lower
     * subqueries, so the Var isn't a subquery output column.
     */
    if (!IS_JOIN_REL(foreignrel))
        return false;
 
    /*
     * If the Var doesn't belong to any lower subqueries, it isn't a subquery
     * output column.
     */
    if (!bms_is_member(node->varno, fpinfo->lower_subquery_rels))
        return false;
 
    if (bms_is_member(node->varno, outerrel->relids))
    {
        /*
         * If outer relation is deparsed as a subquery, the Var is an output
         * column of the subquery; get the IDs for the relation/column alias.
         */
        if (fpinfo->make_outerrel_subquery)
        {
            get_relation_column_alias_ids(node, outerrel, relno, colno);
            return true;
        }
 
        /* Otherwise, recurse into the outer relation. */
        return is_subquery_var(node, outerrel, relno, colno);
    }
    else
    {
        Assert(bms_is_member(node->varno, innerrel->relids));
 
        /*
         * If inner relation is deparsed as a subquery, the Var is an output
         * column of the subquery; get the IDs for the relation/column alias.
         */
        if (fpinfo->make_innerrel_subquery)
        {
            get_relation_column_alias_ids(node, innerrel, relno, colno);
            return true;
        }
 
        /* Otherwise, recurse into the inner relation. */
        return is_subquery_var(node, innerrel, relno, colno);
    }
}

References Assert(), bms_is_member(), get_relation_column_alias_ids(), PgFdwRelationInfo::innerrel, IS_JOIN_REL, IS_SIMPLE_REL, is_subquery_var(), PgFdwRelationInfo::lower_subquery_rels, PgFdwRelationInfo::make_innerrel_subquery, PgFdwRelationInfo::make_outerrel_subquery, PgFdwRelationInfo::outerrel, and Var::varno.

Referenced by deparseVar(), and is_subquery_var().

isPlainForeignVar()

static bool isPlainForeignVar ( Expr *  node, deparse_expr_cxt *  context  )

static

Definition at line 3407 of file deparse.c.

{
    /*
     * We allow the foreign Var to have an implicit RelabelType, mainly so
     * that this'll work with varchar columns.  Note that deparseRelabelType
     * will not print such a cast, so we're not breaking the restriction that
     * the expression print as a plain Var.  We won't risk it for an implicit
     * cast that requires a function, nor for non-implicit RelabelType; such
     * cases seem too likely to involve semantics changes compared to what
     * would happen on the remote side.
     */
    if (IsA(node, RelabelType) &&
        ((RelabelType *) node)->relabelformat == COERCE_IMPLICIT_CAST)
        node = ((RelabelType *) node)->arg;
 
    if (IsA(node, Var))
    {
        /*
         * The Var must be one that'll deparse as a foreign column reference
         * (cf. deparseVar).
         */
        Var        *var = (Var *) node;
        Relids      relids = context->scanrel->relids;
 
        if (bms_is_member(var->varno, relids) && var->varlevelsup == 0)
            return true;
    }
 
    return false;
}

References bms_is_member(), COERCE_IMPLICIT_CAST, IsA, RelOptInfo::relids, deparse_expr_cxt::scanrel, Var::varlevelsup, and Var::varno.

Referenced by deparseOpExpr().

printRemoteParam()

static void printRemoteParam ( int  paramindex, Oid  paramtype, int32  paramtypmod, deparse_expr_cxt *  context  )

static

Definition at line 3877 of file deparse.c.

{
    StringInfo  buf = context->buf;
    char       *ptypename = deparse_type_name(paramtype, paramtypmod);
 
    appendStringInfo(buf, "$%d::%s", paramindex, ptypename);
}

References appendStringInfo(), deparse_expr_cxt::buf, buf, and deparse_type_name().

Referenced by deparseParam(), and deparseVar().

printRemotePlaceholder()

static void printRemotePlaceholder ( Oid  paramtype, int32  paramtypmod, deparse_expr_cxt *  context  )

static

Definition at line 3903 of file deparse.c.

{
    StringInfo  buf = context->buf;
    char       *ptypename = deparse_type_name(paramtype, paramtypmod);
 
    appendStringInfo(buf, "((SELECT null::%s)::%s)", ptypename, ptypename);
}

References appendStringInfo(), deparse_expr_cxt::buf, buf, and deparse_type_name().

Referenced by deparseParam(), and deparseVar().

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 2189 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().