analyze.c File Reference

#include "postgres.h"
#include "access/sysattr.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/queryjumble.h"
#include "optimizer/optimizer.h"
#include "parser/analyze.h"
#include "parser/parse_agg.h"
#include "parser/parse_clause.h"
#include "parser/parse_coerce.h"
#include "parser/parse_collate.h"
#include "parser/parse_cte.h"
#include "parser/parse_expr.h"
#include "parser/parse_func.h"
#include "parser/parse_merge.h"
#include "parser/parse_oper.h"
#include "parser/parse_param.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "parser/parsetree.h"
#include "utils/backend_status.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/rel.h"
#include "utils/syscache.h"

Include dependency graph for analyze.c:

Go to the source code of this file.

Functions
static Query *	transformOptionalSelectInto (ParseState *pstate, Node *parseTree)
static Query *	transformDeleteStmt (ParseState *pstate, DeleteStmt *stmt)
static Query *	transformInsertStmt (ParseState *pstate, InsertStmt *stmt)
static OnConflictExpr *	transformOnConflictClause (ParseState *pstate, OnConflictClause *onConflictClause)
static int	count_rowexpr_columns (ParseState *pstate, Node *expr)
static Query *	transformSelectStmt (ParseState *pstate, SelectStmt *stmt)
static Query *	transformValuesClause (ParseState *pstate, SelectStmt *stmt)
static Query *	transformSetOperationStmt (ParseState *pstate, SelectStmt *stmt)
static Node *	transformSetOperationTree (ParseState *pstate, SelectStmt *stmt, bool isTopLevel, List **targetlist)
static void	determineRecursiveColTypes (ParseState *pstate, Node *larg, List *nrtargetlist)
static Query *	transformReturnStmt (ParseState *pstate, ReturnStmt *stmt)
static Query *	transformUpdateStmt (ParseState *pstate, UpdateStmt *stmt)
static Query *	transformPLAssignStmt (ParseState *pstate, PLAssignStmt *stmt)
static Query *	transformDeclareCursorStmt (ParseState *pstate, DeclareCursorStmt *stmt)
static Query *	transformExplainStmt (ParseState *pstate, ExplainStmt *stmt)
static Query *	transformCreateTableAsStmt (ParseState *pstate, CreateTableAsStmt *stmt)
static Query *	transformCallStmt (ParseState *pstate, CallStmt *stmt)
static void	transformLockingClause (ParseState *pstate, Query *qry, LockingClause *lc, bool pushedDown)
Query *	parse_analyze_fixedparams (RawStmt *parseTree, const char *sourceText, const Oid *paramTypes, int numParams, QueryEnvironment *queryEnv)
Query *	parse_analyze_varparams (RawStmt *parseTree, const char *sourceText, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
Query *	parse_analyze_withcb (RawStmt *parseTree, const char *sourceText, ParserSetupHook parserSetup, void *parserSetupArg, QueryEnvironment *queryEnv)
Query *	parse_sub_analyze (Node *parseTree, ParseState *parentParseState, CommonTableExpr *parentCTE, bool locked_from_parent, bool resolve_unknowns)
static void	setQueryLocationAndLength (ParseState *pstate, Query *qry, Node *parseTree)
Query *	transformTopLevelStmt (ParseState *pstate, RawStmt *parseTree)
Query *	transformStmt (ParseState *pstate, Node *parseTree)
bool	stmt_requires_parse_analysis (RawStmt *parseTree)
bool	analyze_requires_snapshot (RawStmt *parseTree)
bool	query_requires_rewrite_plan (Query *query)
List *	transformInsertRow (ParseState *pstate, List *exprlist, List *stmtcols, List *icolumns, List *attrnos, bool strip_indirection)
List *	BuildOnConflictExcludedTargetlist (Relation targetrel, Index exclRelIndex)
SortGroupClause *	makeSortGroupClauseForSetOp (Oid rescoltype, bool require_hash)
List *	transformUpdateTargetList (ParseState *pstate, List *origTlist)
static void	addNSItemForReturning (ParseState *pstate, const char *aliasname, VarReturningType returning_type)
void	transformReturningClause (ParseState *pstate, Query *qry, ReturningClause *returningClause, ParseExprKind exprKind)
const char *	LCS_asString (LockClauseStrength strength)
void	CheckSelectLocking (Query *qry, LockClauseStrength strength)
void	applyLockingClause (Query *qry, Index rtindex, LockClauseStrength strength, LockWaitPolicy waitPolicy, bool pushedDown)

Variables
post_parse_analyze_hook_type	post_parse_analyze_hook = NULL

Function Documentation

addNSItemForReturning()

static void addNSItemForReturning ( ParseState *  pstate, const char *  aliasname, VarReturningType  returning_type  )

static

Definition at line 2685 of file analyze.c.

{
    List       *colnames;
    int         numattrs;
    ParseNamespaceColumn *nscolumns;
    ParseNamespaceItem *nsitem;
 
    /* copy per-column data from the target relation */
    colnames = pstate->p_target_nsitem->p_rte->eref->colnames;
    numattrs = list_length(colnames);
 
    nscolumns = (ParseNamespaceColumn *)
        palloc(numattrs * sizeof(ParseNamespaceColumn));
 
    memcpy(nscolumns, pstate->p_target_nsitem->p_nscolumns,
           numattrs * sizeof(ParseNamespaceColumn));
 
    /* mark all columns as returning OLD/NEW */
    for (int i = 0; i < numattrs; i++)
        nscolumns[i].p_varreturningtype = returning_type;
 
    /* build the nsitem, copying most fields from the target relation */
    nsitem = (ParseNamespaceItem *) palloc(sizeof(ParseNamespaceItem));
    nsitem->p_names = makeAlias(aliasname, colnames);
    nsitem->p_rte = pstate->p_target_nsitem->p_rte;
    nsitem->p_rtindex = pstate->p_target_nsitem->p_rtindex;
    nsitem->p_perminfo = pstate->p_target_nsitem->p_perminfo;
    nsitem->p_nscolumns = nscolumns;
    nsitem->p_returning_type = returning_type;
 
    /* add it to the query namespace as a table-only item */
    addNSItemToQuery(pstate, nsitem, false, true, false);
}

References addNSItemToQuery(), i, list_length(), makeAlias(), ParseNamespaceItem::p_names, ParseNamespaceItem::p_nscolumns, ParseNamespaceItem::p_perminfo, ParseNamespaceItem::p_returning_type, ParseNamespaceItem::p_rte, ParseNamespaceItem::p_rtindex, ParseState::p_target_nsitem, and palloc().

Referenced by transformReturningClause().

analyze_requires_snapshot()

bool analyze_requires_snapshot

(

RawStmt *

parseTree

)

Definition at line 571 of file analyze.c.

{
    /*
     * Currently, this should return true in exactly the same cases that
     * stmt_requires_parse_analysis() does, so we just invoke that function
     * rather than duplicating it.  We keep the two entry points separate for
     * clarity of callers, since from the callers' standpoint these are
     * different conditions.
     *
     * While there may someday be a statement type for which transformStmt()
     * does something nontrivial and yet no snapshot is needed for that
     * processing, it seems likely that making such a choice would be fragile.
     * If you want to install an exception, document the reasoning for it in a
     * comment.
     */
    return stmt_requires_parse_analysis(parseTree);
}

References stmt_requires_parse_analysis().

Referenced by BuildingPlanRequiresSnapshot(), exec_bind_message(), exec_parse_message(), and exec_simple_query().

applyLockingClause()

void applyLockingClause	(	Query *	qry,
		Index	rtindex,
		LockClauseStrength	strength,
		LockWaitPolicy	waitPolicy,
		bool	pushedDown
	)

Definition at line 3757 of file analyze.c.

{
    RowMarkClause *rc;
 
    Assert(strength != LCS_NONE);   /* else caller error */
 
    /* If it's an explicit clause, make sure hasForUpdate gets set */
    if (!pushedDown)
        qry->hasForUpdate = true;
 
    /* Check for pre-existing entry for same rtindex */
    if ((rc = get_parse_rowmark(qry, rtindex)) != NULL)
    {
        /*
         * If the same RTE is specified with more than one locking strength,
         * use the strongest.  (Reasonable, since you can't take both a shared
         * and exclusive lock at the same time; it'll end up being exclusive
         * anyway.)
         *
         * Similarly, if the same RTE is specified with more than one lock
         * wait policy, consider that NOWAIT wins over SKIP LOCKED, which in
         * turn wins over waiting for the lock (the default).  This is a bit
         * more debatable but raising an error doesn't seem helpful. (Consider
         * for instance SELECT FOR UPDATE NOWAIT from a view that internally
         * contains a plain FOR UPDATE spec.)  Having NOWAIT win over SKIP
         * LOCKED is reasonable since the former throws an error in case of
         * coming across a locked tuple, which may be undesirable in some
         * cases but it seems better than silently returning inconsistent
         * results.
         *
         * And of course pushedDown becomes false if any clause is explicit.
         */
        rc->strength = Max(rc->strength, strength);
        rc->waitPolicy = Max(rc->waitPolicy, waitPolicy);
        rc->pushedDown &= pushedDown;
        return;
    }
 
    /* Make a new RowMarkClause */
    rc = makeNode(RowMarkClause);
    rc->rti = rtindex;
    rc->strength = strength;
    rc->waitPolicy = waitPolicy;
    rc->pushedDown = pushedDown;
    qry->rowMarks = lappend(qry->rowMarks, rc);
}

References Assert(), get_parse_rowmark(), lappend(), LCS_NONE, makeNode, Max, RowMarkClause::pushedDown, Query::rowMarks, RowMarkClause::rti, RowMarkClause::strength, and RowMarkClause::waitPolicy.

Referenced by markQueryForLocking(), and transformLockingClause().

BuildOnConflictExcludedTargetlist()

List * BuildOnConflictExcludedTargetlist	(	Relation	targetrel,
		Index	exclRelIndex
	)

Definition at line 1349 of file analyze.c.

{
    List       *result = NIL;
    int         attno;
    Var        *var;
    TargetEntry *te;
 
    /*
     * Note that resnos of the tlist must correspond to attnos of the
     * underlying relation, hence we need entries for dropped columns too.
     */
    for (attno = 0; attno < RelationGetNumberOfAttributes(targetrel); attno++)
    {
        Form_pg_attribute attr = TupleDescAttr(targetrel->rd_att, attno);
        char       *name;
 
        if (attr->attisdropped)
        {
            /*
             * can't use atttypid here, but it doesn't really matter what type
             * the Const claims to be.
             */
            var = (Var *) makeNullConst(INT4OID, -1, InvalidOid);
            name = NULL;
        }
        else
        {
            var = makeVar(exclRelIndex, attno + 1,
                          attr->atttypid, attr->atttypmod,
                          attr->attcollation,
                          0);
            name = pstrdup(NameStr(attr->attname));
        }
 
        te = makeTargetEntry((Expr *) var,
                             attno + 1,
                             name,
                             false);
 
        result = lappend(result, te);
    }
 
    /*
     * Add a whole-row-Var entry to support references to "EXCLUDED.*".  Like
     * the other entries in the EXCLUDED tlist, its resno must match the Var's
     * varattno, else the wrong things happen while resolving references in
     * setrefs.c.  This is against normal conventions for targetlists, but
     * it's okay since we don't use this as a real tlist.
     */
    var = makeVar(exclRelIndex, InvalidAttrNumber,
                  targetrel->rd_rel->reltype,
                  -1, InvalidOid, 0);
    te = makeTargetEntry((Expr *) var, InvalidAttrNumber, NULL, true);
    result = lappend(result, te);
 
    return result;
}

References InvalidAttrNumber, InvalidOid, lappend(), makeNullConst(), makeTargetEntry(), makeVar(), name, NameStr, NIL, pstrdup(), RelationData::rd_att, RelationData::rd_rel, RelationGetNumberOfAttributes, and TupleDescAttr().

Referenced by rewriteTargetView(), and transformOnConflictClause().

CheckSelectLocking()

void CheckSelectLocking	(	Query *	qry,
		LockClauseStrength	strength
	)

Definition at line 3466 of file analyze.c.

{
    Assert(strength != LCS_NONE);   /* else caller error */
 
    if (qry->setOperations)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
                        LCS_asString(strength))));
    if (qry->distinctClause != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with DISTINCT clause",
                        LCS_asString(strength))));
    if (qry->groupClause != NIL || qry->groupingSets != NIL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with GROUP BY clause",
                        LCS_asString(strength))));
    if (qry->havingQual != NULL)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with HAVING clause",
                        LCS_asString(strength))));
    if (qry->hasAggs)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with aggregate functions",
                        LCS_asString(strength))));
    if (qry->hasWindowFuncs)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with window functions",
                        LCS_asString(strength))));
    if (qry->hasTargetSRFs)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with set-returning functions in the target list",
                        LCS_asString(strength))));
}

References Assert(), Query::distinctClause, ereport, errcode(), errmsg(), ERROR, Query::groupClause, Query::groupingSets, Query::havingQual, LCS_asString(), LCS_NONE, NIL, and Query::setOperations.

Referenced by preprocess_rowmarks(), and transformLockingClause().

count_rowexpr_columns()

static int count_rowexpr_columns ( ParseState *  pstate, Node *  expr  )

static

Definition at line 1419 of file analyze.c.

{
    if (expr == NULL)
        return -1;
    if (IsA(expr, RowExpr))
        return list_length(((RowExpr *) expr)->args);
    if (IsA(expr, Var))
    {
        Var        *var = (Var *) expr;
        AttrNumber  attnum = var->varattno;
 
        if (attnum > 0 && var->vartype == RECORDOID)
        {
            RangeTblEntry *rte;
 
            rte = GetRTEByRangeTablePosn(pstate, var->varno, var->varlevelsup);
            if (rte->rtekind == RTE_SUBQUERY)
            {
                /* Subselect-in-FROM: examine sub-select's output expr */
                TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
                                                    attnum);
 
                if (ste == NULL || ste->resjunk)
                    return -1;
                expr = (Node *) ste->expr;
                if (IsA(expr, RowExpr))
                    return list_length(((RowExpr *) expr)->args);
            }
        }
    }
    return -1;
}

References generate_unaccent_rules::args, attnum, TargetEntry::expr, get_tle_by_resno(), GetRTEByRangeTablePosn(), if(), IsA, list_length(), RTE_SUBQUERY, RangeTblEntry::rtekind, RangeTblEntry::subquery, Query::targetList, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by transformInsertRow().

determineRecursiveColTypes()

static void determineRecursiveColTypes ( ParseState *  pstate, Node *  larg, List *  nrtargetlist  )

static

Definition at line 2459 of file analyze.c.

{
    Node       *node;
    int         leftmostRTI;
    Query      *leftmostQuery;
    List       *targetList;
    ListCell   *left_tlist;
    ListCell   *nrtl;
    int         next_resno;
 
    /*
     * Find leftmost leaf SELECT
     */
    node = larg;
    while (node && IsA(node, SetOperationStmt))
        node = ((SetOperationStmt *) node)->larg;
    Assert(node && IsA(node, RangeTblRef));
    leftmostRTI = ((RangeTblRef *) node)->rtindex;
    leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery;
    Assert(leftmostQuery != NULL);
 
    /*
     * Generate dummy targetlist using column names of leftmost select and
     * dummy result expressions of the non-recursive term.
     */
    targetList = NIL;
    next_resno = 1;
 
    forboth(nrtl, nrtargetlist, left_tlist, leftmostQuery->targetList)
    {
        TargetEntry *nrtle = (TargetEntry *) lfirst(nrtl);
        TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist);
        char       *colName;
        TargetEntry *tle;
 
        Assert(!lefttle->resjunk);
        colName = pstrdup(lefttle->resname);
        tle = makeTargetEntry(nrtle->expr,
                              next_resno++,
                              colName,
                              false);
        targetList = lappend(targetList, tle);
    }
 
    /* Now build CTE's output column info using dummy targetlist */
    analyzeCTETargetList(pstate, pstate->p_parent_cte, targetList);
}

References analyzeCTETargetList(), Assert(), TargetEntry::expr, forboth, IsA, lappend(), lfirst, makeTargetEntry(), NIL, ParseState::p_parent_cte, ParseState::p_rtable, pstrdup(), rt_fetch, and Query::targetList.

Referenced by transformSetOperationTree().

LCS_asString()

const char * LCS_asString

(

LockClauseStrength

strength

)

Definition at line 3441 of file analyze.c.

{
    switch (strength)
    {
        case LCS_NONE:
            Assert(false);
            break;
        case LCS_FORKEYSHARE:
            return "FOR KEY SHARE";
        case LCS_FORSHARE:
            return "FOR SHARE";
        case LCS_FORNOKEYUPDATE:
            return "FOR NO KEY UPDATE";
        case LCS_FORUPDATE:
            return "FOR UPDATE";
    }
    return "FOR some";          /* shouldn't happen */
}

References Assert(), LCS_FORKEYSHARE, LCS_FORNOKEYUPDATE, LCS_FORSHARE, LCS_FORUPDATE, and LCS_NONE.

Referenced by CheckSelectLocking(), grouping_planner(), make_outerjoininfo(), transformDeclareCursorStmt(), transformLockingClause(), transformSetOperationStmt(), transformSetOperationTree(), and transformValuesClause().

makeSortGroupClauseForSetOp()

SortGroupClause * makeSortGroupClauseForSetOp	(	Oid	rescoltype,
		bool	require_hash
	)

Definition at line 2080 of file analyze.c.

{
    SortGroupClause *grpcl = makeNode(SortGroupClause);
    Oid         sortop;
    Oid         eqop;
    bool        hashable;
 
    /* determine the eqop and optional sortop */
    get_sort_group_operators(rescoltype,
                             false, true, false,
                             &sortop, &eqop, NULL,
                             &hashable);
 
    /*
     * The type cache doesn't believe that record is hashable (see
     * cache_record_field_properties()), but if the caller really needs hash
     * support, we can assume it does.  Worst case, if any components of the
     * record don't support hashing, we will fail at execution.
     */
    if (require_hash && (rescoltype == RECORDOID || rescoltype == RECORDARRAYOID))
        hashable = true;
 
    /* we don't have a tlist yet, so can't assign sortgrouprefs */
    grpcl->tleSortGroupRef = 0;
    grpcl->eqop = eqop;
    grpcl->sortop = sortop;
    grpcl->reverse_sort = false;    /* Sort-op is "less than", or InvalidOid */
    grpcl->nulls_first = false; /* OK with or without sortop */
    grpcl->hashable = hashable;
 
    return grpcl;
}

References SortGroupClause::eqop, get_sort_group_operators(), makeNode, SortGroupClause::nulls_first, SortGroupClause::reverse_sort, SortGroupClause::sortop, and SortGroupClause::tleSortGroupRef.

Referenced by rewriteSearchAndCycle(), and transformSetOperationTree().

parse_analyze_fixedparams()

Query * parse_analyze_fixedparams	(	RawStmt *	parseTree,
		const char *	sourceText,
		const Oid *	paramTypes,
		int	numParams,
		QueryEnvironment *	queryEnv
	)

Definition at line 105 of file analyze.c.

{
    ParseState *pstate = make_parsestate(NULL);
    Query      *query;
    JumbleState *jstate = NULL;
 
    Assert(sourceText != NULL); /* required as of 8.4 */
 
    pstate->p_sourcetext = sourceText;
 
    if (numParams > 0)
        setup_parse_fixed_parameters(pstate, paramTypes, numParams);
 
    pstate->p_queryEnv = queryEnv;
 
    query = transformTopLevelStmt(pstate, parseTree);
 
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    free_parsestate(pstate);
 
    pgstat_report_query_id(query->queryId, false);
 
    return query;
}

References Assert(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, setup_parse_fixed_parameters(), and transformTopLevelStmt().

Referenced by DefineView(), and pg_analyze_and_rewrite_fixedparams().

parse_analyze_varparams()

Query * parse_analyze_varparams	(	RawStmt *	parseTree,
		const char *	sourceText,
		Oid **	paramTypes,
		int *	numParams,
		QueryEnvironment *	queryEnv
	)

Definition at line 145 of file analyze.c.

{
    ParseState *pstate = make_parsestate(NULL);
    Query      *query;
    JumbleState *jstate = NULL;
 
    Assert(sourceText != NULL); /* required as of 8.4 */
 
    pstate->p_sourcetext = sourceText;
 
    setup_parse_variable_parameters(pstate, paramTypes, numParams);
 
    pstate->p_queryEnv = queryEnv;
 
    query = transformTopLevelStmt(pstate, parseTree);
 
    /* make sure all is well with parameter types */
    check_variable_parameters(pstate, query);
 
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    free_parsestate(pstate);
 
    pgstat_report_query_id(query->queryId, false);
 
    return query;
}

References Assert(), check_variable_parameters(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, setup_parse_variable_parameters(), and transformTopLevelStmt().

Referenced by pg_analyze_and_rewrite_varparams().

parse_analyze_withcb()

Query * parse_analyze_withcb	(	RawStmt *	parseTree,
		const char *	sourceText,
		ParserSetupHook	parserSetup,
		void *	parserSetupArg,
		QueryEnvironment *	queryEnv
	)

Definition at line 186 of file analyze.c.

{
    ParseState *pstate = make_parsestate(NULL);
    Query      *query;
    JumbleState *jstate = NULL;
 
    Assert(sourceText != NULL); /* required as of 8.4 */
 
    pstate->p_sourcetext = sourceText;
    pstate->p_queryEnv = queryEnv;
    (*parserSetup) (pstate, parserSetupArg);
 
    query = transformTopLevelStmt(pstate, parseTree);
 
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    free_parsestate(pstate);
 
    pgstat_report_query_id(query->queryId, false);
 
    return query;
}

References Assert(), free_parsestate(), IsQueryIdEnabled(), JumbleQuery(), make_parsestate(), ParseState::p_queryEnv, ParseState::p_sourcetext, pgstat_report_query_id(), post_parse_analyze_hook, and transformTopLevelStmt().

Referenced by pg_analyze_and_rewrite_withcb().

parse_sub_analyze()

Query * parse_sub_analyze	(	Node *	parseTree,
		ParseState *	parentParseState,
		CommonTableExpr *	parentCTE,
		bool	locked_from_parent,
		bool	resolve_unknowns
	)

Definition at line 222 of file analyze.c.

{
    ParseState *pstate = make_parsestate(parentParseState);
    Query      *query;
 
    pstate->p_parent_cte = parentCTE;
    pstate->p_locked_from_parent = locked_from_parent;
    pstate->p_resolve_unknowns = resolve_unknowns;
 
    query = transformStmt(pstate, parseTree);
 
    free_parsestate(pstate);
 
    return query;
}

References free_parsestate(), make_parsestate(), ParseState::p_locked_from_parent, ParseState::p_parent_cte, ParseState::p_resolve_unknowns, and transformStmt().

Referenced by analyzeCTE(), transformRangeSubselect(), transformSetOperationTree(), and transformSubLink().

query_requires_rewrite_plan()

bool query_requires_rewrite_plan

(

Query *

query

)

Definition at line 600 of file analyze.c.

{
    bool        result;
 
    if (query->commandType != CMD_UTILITY)
    {
        /* All optimizable statements require rewriting/planning */
        result = true;
    }
    else
    {
        /* This list should match stmt_requires_parse_analysis() */
        switch (nodeTag(query->utilityStmt))
        {
            case T_DeclareCursorStmt:
            case T_ExplainStmt:
            case T_CreateTableAsStmt:
            case T_CallStmt:
                result = true;
                break;
            default:
                result = false;
                break;
        }
    }
    return result;
}

References CMD_UTILITY, Query::commandType, nodeTag, and Query::utilityStmt.

Referenced by BuildingPlanRequiresSnapshot(), and StmtPlanRequiresRevalidation().

setQueryLocationAndLength()

static void setQueryLocationAndLength ( ParseState *  pstate, Query *  qry, Node *  parseTree  )

static

Definition at line 260 of file analyze.c.

{
    ParseLoc    stmt_len = 0;
 
    switch (nodeTag(parseTree))
    {
        case T_InsertStmt:
            qry->stmt_location = ((InsertStmt *) parseTree)->stmt_location;
            stmt_len = ((InsertStmt *) parseTree)->stmt_len;
            break;
 
        case T_DeleteStmt:
            qry->stmt_location = ((DeleteStmt *) parseTree)->stmt_location;
            stmt_len = ((DeleteStmt *) parseTree)->stmt_len;
            break;
 
        case T_UpdateStmt:
            qry->stmt_location = ((UpdateStmt *) parseTree)->stmt_location;
            stmt_len = ((UpdateStmt *) parseTree)->stmt_len;
            break;
 
        case T_MergeStmt:
            qry->stmt_location = ((MergeStmt *) parseTree)->stmt_location;
            stmt_len = ((MergeStmt *) parseTree)->stmt_len;
            break;
 
        case T_SelectStmt:
            qry->stmt_location = ((SelectStmt *) parseTree)->stmt_location;
            stmt_len = ((SelectStmt *) parseTree)->stmt_len;
            break;
 
        case T_PLAssignStmt:
            qry->stmt_location = ((PLAssignStmt *) parseTree)->location;
            break;
 
        default:
            qry->stmt_location = pstate->p_stmt_location;
            break;
    }
 
    if (stmt_len > 0)
    {
        /* Statement's length is known, use it */
        qry->stmt_len = stmt_len;
    }
    else if (pstate->p_stmt_len > 0)
    {
        /*
         * The top RawStmt's length is known, so calculate the statement's
         * length from the statement's location and the RawStmt's length and
         * location.
         */
        qry->stmt_len = pstate->p_stmt_len - (qry->stmt_location - pstate->p_stmt_location);
    }
 
    /* The calculated statement length should be calculated as positive. */
    Assert(qry->stmt_len >= 0);
}

References Assert(), nodeTag, ParseState::p_stmt_len, ParseState::p_stmt_location, and Query::stmt_location.

Referenced by transformStmt().

stmt_requires_parse_analysis()

bool stmt_requires_parse_analysis

(

RawStmt *

parseTree

)

Definition at line 527 of file analyze.c.

{
    bool        result;
 
    switch (nodeTag(parseTree->stmt))
    {
            /*
             * Optimizable statements
             */
        case T_InsertStmt:
        case T_DeleteStmt:
        case T_UpdateStmt:
        case T_MergeStmt:
        case T_SelectStmt:
        case T_ReturnStmt:
        case T_PLAssignStmt:
            result = true;
            break;
 
            /*
             * Special cases
             */
        case T_DeclareCursorStmt:
        case T_ExplainStmt:
        case T_CreateTableAsStmt:
        case T_CallStmt:
            result = true;
            break;
 
        default:
            /* all other statements just get wrapped in a CMD_UTILITY Query */
            result = false;
            break;
    }
 
    return result;
}

References nodeTag, and RawStmt::stmt.

Referenced by analyze_requires_snapshot(), and StmtPlanRequiresRevalidation().

transformCallStmt()

static Query * transformCallStmt ( ParseState *  pstate, CallStmt *  stmt  )

static

Definition at line 3316 of file analyze.c.

{
    List       *targs;
    ListCell   *lc;
    Node       *node;
    FuncExpr   *fexpr;
    HeapTuple   proctup;
    Datum       proargmodes;
    bool        isNull;
    List       *outargs = NIL;
    Query      *result;
 
    /*
     * First, do standard parse analysis on the procedure call and its
     * arguments, allowing us to identify the called procedure.
     */
    targs = NIL;
    foreach(lc, stmt->funccall->args)
    {
        targs = lappend(targs, transformExpr(pstate,
                                             (Node *) lfirst(lc),
                                             EXPR_KIND_CALL_ARGUMENT));
    }
 
    node = ParseFuncOrColumn(pstate,
                             stmt->funccall->funcname,
                             targs,
                             pstate->p_last_srf,
                             stmt->funccall,
                             true,
                             stmt->funccall->location);
 
    assign_expr_collations(pstate, node);
 
    fexpr = castNode(FuncExpr, node);
 
    proctup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fexpr->funcid));
    if (!HeapTupleIsValid(proctup))
        elog(ERROR, "cache lookup failed for function %u", fexpr->funcid);
 
    /*
     * Expand the argument list to deal with named-argument notation and
     * default arguments.  For ordinary FuncExprs this'd be done during
     * planning, but a CallStmt doesn't go through planning, and there seems
     * no good reason not to do it here.
     */
    fexpr->args = expand_function_arguments(fexpr->args,
                                            true,
                                            fexpr->funcresulttype,
                                            proctup);
 
    /* Fetch proargmodes; if it's null, there are no output args */
    proargmodes = SysCacheGetAttr(PROCOID, proctup,
                                  Anum_pg_proc_proargmodes,
                                  &isNull);
    if (!isNull)
    {
        /*
         * Split the list into input arguments in fexpr->args and output
         * arguments in stmt->outargs.  INOUT arguments appear in both lists.
         */
        ArrayType  *arr;
        int         numargs;
        char       *argmodes;
        List       *inargs;
        int         i;
 
        arr = DatumGetArrayTypeP(proargmodes);  /* ensure not toasted */
        numargs = list_length(fexpr->args);
        if (ARR_NDIM(arr) != 1 ||
            ARR_DIMS(arr)[0] != numargs ||
            ARR_HASNULL(arr) ||
            ARR_ELEMTYPE(arr) != CHAROID)
            elog(ERROR, "proargmodes is not a 1-D char array of length %d or it contains nulls",
                 numargs);
        argmodes = (char *) ARR_DATA_PTR(arr);
 
        inargs = NIL;
        i = 0;
        foreach(lc, fexpr->args)
        {
            Node       *n = lfirst(lc);
 
            switch (argmodes[i])
            {
                case PROARGMODE_IN:
                case PROARGMODE_VARIADIC:
                    inargs = lappend(inargs, n);
                    break;
                case PROARGMODE_OUT:
                    outargs = lappend(outargs, n);
                    break;
                case PROARGMODE_INOUT:
                    inargs = lappend(inargs, n);
                    outargs = lappend(outargs, copyObject(n));
                    break;
                default:
                    /* note we don't support PROARGMODE_TABLE */
                    elog(ERROR, "invalid argmode %c for procedure",
                         argmodes[i]);
                    break;
            }
            i++;
        }
        fexpr->args = inargs;
    }
 
    stmt->funcexpr = fexpr;
    stmt->outargs = outargs;
 
    ReleaseSysCache(proctup);
 
    /* represent the command as a utility Query */
    result = makeNode(Query);
    result->commandType = CMD_UTILITY;
    result->utilityStmt = (Node *) stmt;
 
    return result;
}

References FuncExpr::args, ARR_DATA_PTR, ARR_DIMS, ARR_ELEMTYPE, ARR_HASNULL, ARR_NDIM, assign_expr_collations(), castNode, CMD_UTILITY, Query::commandType, copyObject, DatumGetArrayTypeP, elog, ERROR, expand_function_arguments(), EXPR_KIND_CALL_ARGUMENT, FuncExpr::funcid, HeapTupleIsValid, i, lappend(), lfirst, list_length(), makeNode, NIL, ObjectIdGetDatum(), ParseState::p_last_srf, ParseFuncOrColumn(), ReleaseSysCache(), SearchSysCache1(), stmt, SysCacheGetAttr(), transformExpr(), and Query::utilityStmt.

Referenced by transformStmt().

transformCreateTableAsStmt()

static Query * transformCreateTableAsStmt ( ParseState *  pstate, CreateTableAsStmt *  stmt  )

static

Definition at line 3241 of file analyze.c.

{
    Query      *result;
    Query      *query;
 
    /* transform contained query, not allowing SELECT INTO */
    query = transformStmt(pstate, stmt->query);
    stmt->query = (Node *) query;
 
    /* additional work needed for CREATE MATERIALIZED VIEW */
    if (stmt->objtype == OBJECT_MATVIEW)
    {
        /*
         * Prohibit a data-modifying CTE in the query used to create a
         * materialized view. It's not sufficiently clear what the user would
         * want to happen if the MV is refreshed or incrementally maintained.
         */
        if (query->hasModifyingCTE)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("materialized views must not use data-modifying statements in WITH")));
 
        /*
         * Check whether any temporary database objects are used in the
         * creation query. It would be hard to refresh data or incrementally
         * maintain it if a source disappeared.
         */
        if (isQueryUsingTempRelation(query))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("materialized views must not use temporary tables or views")));
 
        /*
         * A materialized view would either need to save parameters for use in
         * maintaining/loading the data or prohibit them entirely.  The latter
         * seems safer and more sane.
         */
        if (query_contains_extern_params(query))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("materialized views may not be defined using bound parameters")));
 
        /*
         * For now, we disallow unlogged materialized views, because it seems
         * like a bad idea for them to just go to empty after a crash. (If we
         * could mark them as unpopulated, that would be better, but that
         * requires catalog changes which crash recovery can't presently
         * handle.)
         */
        if (stmt->into->rel->relpersistence == RELPERSISTENCE_UNLOGGED)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("materialized views cannot be unlogged")));
 
        /*
         * At runtime, we'll need a copy of the parsed-but-not-rewritten Query
         * for purposes of creating the view's ON SELECT rule.  We stash that
         * in the IntoClause because that's where intorel_startup() can
         * conveniently get it from.
         */
        stmt->into->viewQuery = copyObject(query);
    }
 
    /* represent the command as a utility Query */
    result = makeNode(Query);
    result->commandType = CMD_UTILITY;
    result->utilityStmt = (Node *) stmt;
 
    return result;
}

References CMD_UTILITY, Query::commandType, copyObject, ereport, errcode(), errmsg(), ERROR, isQueryUsingTempRelation(), makeNode, OBJECT_MATVIEW, query_contains_extern_params(), stmt, transformStmt(), and Query::utilityStmt.

Referenced by transformStmt().

transformDeclareCursorStmt()

static Query * transformDeclareCursorStmt ( ParseState *  pstate, DeclareCursorStmt *  stmt  )

static

Definition at line 3096 of file analyze.c.

{
    Query      *result;
    Query      *query;
 
    if ((stmt->options & CURSOR_OPT_SCROLL) &&
        (stmt->options & CURSOR_OPT_NO_SCROLL))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
        /* translator: %s is a SQL keyword */
                 errmsg("cannot specify both %s and %s",
                        "SCROLL", "NO SCROLL")));
 
    if ((stmt->options & CURSOR_OPT_ASENSITIVE) &&
        (stmt->options & CURSOR_OPT_INSENSITIVE))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
        /* translator: %s is a SQL keyword */
                 errmsg("cannot specify both %s and %s",
                        "ASENSITIVE", "INSENSITIVE")));
 
    /* Transform contained query, not allowing SELECT INTO */
    query = transformStmt(pstate, stmt->query);
    stmt->query = (Node *) query;
 
    /* Grammar should not have allowed anything but SELECT */
    if (!IsA(query, Query) ||
        query->commandType != CMD_SELECT)
        elog(ERROR, "unexpected non-SELECT command in DECLARE CURSOR");
 
    /*
     * We also disallow data-modifying WITH in a cursor.  (This could be
     * allowed, but the semantics of when the updates occur might be
     * surprising.)
     */
    if (query->hasModifyingCTE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("DECLARE CURSOR must not contain data-modifying statements in WITH")));
 
    /* FOR UPDATE and WITH HOLD are not compatible */
    if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_HOLD))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("DECLARE CURSOR WITH HOLD ... %s is not supported",
                        LCS_asString(((RowMarkClause *)
                                      linitial(query->rowMarks))->strength)),
                 errdetail("Holdable cursors must be READ ONLY.")));
 
    /* FOR UPDATE and SCROLL are not compatible */
    if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_SCROLL))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("DECLARE SCROLL CURSOR ... %s is not supported",
                        LCS_asString(((RowMarkClause *)
                                      linitial(query->rowMarks))->strength)),
                 errdetail("Scrollable cursors must be READ ONLY.")));
 
    /* FOR UPDATE and INSENSITIVE are not compatible */
    if (query->rowMarks != NIL && (stmt->options & CURSOR_OPT_INSENSITIVE))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_CURSOR_DEFINITION),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("DECLARE INSENSITIVE CURSOR ... %s is not valid",
                        LCS_asString(((RowMarkClause *)
                                      linitial(query->rowMarks))->strength)),
                 errdetail("Insensitive cursors must be READ ONLY.")));
 
    /* represent the command as a utility Query */
    result = makeNode(Query);
    result->commandType = CMD_UTILITY;
    result->utilityStmt = (Node *) stmt;
 
    return result;
}

References CMD_SELECT, CMD_UTILITY, Query::commandType, CURSOR_OPT_ASENSITIVE, CURSOR_OPT_HOLD, CURSOR_OPT_INSENSITIVE, CURSOR_OPT_NO_SCROLL, CURSOR_OPT_SCROLL, elog, ereport, errcode(), errdetail(), errmsg(), ERROR, IsA, LCS_asString(), linitial, makeNode, NIL, Query::rowMarks, stmt, transformStmt(), and Query::utilityStmt.

Referenced by transformStmt().

transformDeleteStmt()

static Query * transformDeleteStmt ( ParseState *  pstate, DeleteStmt *  stmt  )

static

Definition at line 633 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    ParseNamespaceItem *nsitem;
    Node       *qual;
 
    qry->commandType = CMD_DELETE;
 
    /* process the WITH clause independently of all else */
    if (stmt->withClause)
    {
        qry->hasRecursive = stmt->withClause->recursive;
        qry->cteList = transformWithClause(pstate, stmt->withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    /* set up range table with just the result rel */
    qry->resultRelation = setTargetTable(pstate, stmt->relation,
                                         stmt->relation->inh,
                                         true,
                                         ACL_DELETE);
    nsitem = pstate->p_target_nsitem;
 
    /* there's no DISTINCT in DELETE */
    qry->distinctClause = NIL;
 
    /* subqueries in USING cannot access the result relation */
    nsitem->p_lateral_only = true;
    nsitem->p_lateral_ok = false;
 
    /*
     * The USING clause is non-standard SQL syntax, and is equivalent in
     * functionality to the FROM list that can be specified for UPDATE. The
     * USING keyword is used rather than FROM because FROM is already a
     * keyword in the DELETE syntax.
     */
    transformFromClause(pstate, stmt->usingClause);
 
    /* remaining clauses can reference the result relation normally */
    nsitem->p_lateral_only = false;
    nsitem->p_lateral_ok = true;
 
    qual = transformWhereClause(pstate, stmt->whereClause,
                                EXPR_KIND_WHERE, "WHERE");
 
    transformReturningClause(pstate, qry, stmt->returningClause,
                             EXPR_KIND_RETURNING);
 
    /* done building the range table and jointree */
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
 
    qry->hasSubLinks = pstate->p_hasSubLinks;
    qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasAggs = pstate->p_hasAggs;
 
    assign_query_collations(pstate, qry);
 
    /* this must be done after collations, for reliable comparison of exprs */
    if (pstate->p_hasAggs)
        parseCheckAggregates(pstate, qry);
 
    return qry;
}

References ACL_DELETE, assign_query_collations(), CMD_DELETE, Query::commandType, Query::cteList, Query::distinctClause, EXPR_KIND_RETURNING, EXPR_KIND_WHERE, Query::jointree, makeFromExpr(), makeNode, NIL, ParseState::p_hasAggs, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseNamespaceItem::p_lateral_ok, ParseNamespaceItem::p_lateral_only, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_target_nsitem, parseCheckAggregates(), Query::rtable, setTargetTable(), stmt, transformFromClause(), transformReturningClause(), transformWhereClause(), and transformWithClause().

Referenced by transformStmt().

transformExplainStmt()

static Query * transformExplainStmt ( ParseState *  pstate, ExplainStmt *  stmt  )

static

Definition at line 3189 of file analyze.c.

{
    Query      *result;
    bool        generic_plan = false;
    Oid        *paramTypes = NULL;
    int         numParams = 0;
 
    /*
     * If we have no external source of parameter definitions, and the
     * GENERIC_PLAN option is specified, then accept variable parameter
     * definitions (similarly to PREPARE, for example).
     */
    if (pstate->p_paramref_hook == NULL)
    {
        ListCell   *lc;
 
        foreach(lc, stmt->options)
        {
            DefElem    *opt = (DefElem *) lfirst(lc);
 
            if (strcmp(opt->defname, "generic_plan") == 0)
                generic_plan = defGetBoolean(opt);
            /* don't "break", as we want the last value */
        }
        if (generic_plan)
            setup_parse_variable_parameters(pstate, &paramTypes, &numParams);
    }
 
    /* transform contained query, allowing SELECT INTO */
    stmt->query = (Node *) transformOptionalSelectInto(pstate, stmt->query);
 
    /* make sure all is well with parameter types */
    if (generic_plan)
        check_variable_parameters(pstate, (Query *) stmt->query);
 
    /* represent the command as a utility Query */
    result = makeNode(Query);
    result->commandType = CMD_UTILITY;
    result->utilityStmt = (Node *) stmt;
 
    return result;
}

References check_variable_parameters(), CMD_UTILITY, Query::commandType, defGetBoolean(), DefElem::defname, lfirst, makeNode, ParseState::p_paramref_hook, setup_parse_variable_parameters(), stmt, transformOptionalSelectInto(), and Query::utilityStmt.

Referenced by transformStmt().

transformInsertRow()

List * transformInsertRow	(	ParseState *	pstate,
		List *	exprlist,
		List *	stmtcols,
		List *	icolumns,
		List *	attrnos,
		bool	strip_indirection
	)

Definition at line 1132 of file analyze.c.

{
    List       *result;
    ListCell   *lc;
    ListCell   *icols;
    ListCell   *attnos;
 
    /*
     * Check length of expr list.  It must not have more expressions than
     * there are target columns.  We allow fewer, but only if no explicit
     * columns list was given (the remaining columns are implicitly
     * defaulted).  Note we must check this *after* transformation because
     * that could expand '*' into multiple items.
     */
    if (list_length(exprlist) > list_length(icolumns))
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("INSERT has more expressions than target columns"),
                 parser_errposition(pstate,
                                    exprLocation(list_nth(exprlist,
                                                          list_length(icolumns))))));
    if (stmtcols != NIL &&
        list_length(exprlist) < list_length(icolumns))
    {
        /*
         * We can get here for cases like INSERT ... SELECT (a,b,c) FROM ...
         * where the user accidentally created a RowExpr instead of separate
         * columns.  Add a suitable hint if that seems to be the problem,
         * because the main error message is quite misleading for this case.
         * (If there's no stmtcols, you'll get something about data type
         * mismatch, which is less misleading so we don't worry about giving a
         * hint in that case.)
         */
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("INSERT has more target columns than expressions"),
                 ((list_length(exprlist) == 1 &&
                   count_rowexpr_columns(pstate, linitial(exprlist)) ==
                   list_length(icolumns)) ?
                  errhint("The insertion source is a row expression containing the same number of columns expected by the INSERT. Did you accidentally use extra parentheses?") : 0),
                 parser_errposition(pstate,
                                    exprLocation(list_nth(icolumns,
                                                          list_length(exprlist))))));
    }
 
    /*
     * Prepare columns for assignment to target table.
     */
    result = NIL;
    forthree(lc, exprlist, icols, icolumns, attnos, attrnos)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        ResTarget  *col = lfirst_node(ResTarget, icols);
        int         attno = lfirst_int(attnos);
 
        expr = transformAssignedExpr(pstate, expr,
                                     EXPR_KIND_INSERT_TARGET,
                                     col->name,
                                     attno,
                                     col->indirection,
                                     col->location);
 
        if (strip_indirection)
        {
            /*
             * We need to remove top-level FieldStores and SubscriptingRefs,
             * as well as any CoerceToDomain appearing above one of those ---
             * but not a CoerceToDomain that isn't above one of those.
             */
            while (expr)
            {
                Expr       *subexpr = expr;
 
                while (IsA(subexpr, CoerceToDomain))
                {
                    subexpr = ((CoerceToDomain *) subexpr)->arg;
                }
                if (IsA(subexpr, FieldStore))
                {
                    FieldStore *fstore = (FieldStore *) subexpr;
 
                    expr = (Expr *) linitial(fstore->newvals);
                }
                else if (IsA(subexpr, SubscriptingRef))
                {
                    SubscriptingRef *sbsref = (SubscriptingRef *) subexpr;
 
                    if (sbsref->refassgnexpr == NULL)
                        break;
 
                    expr = sbsref->refassgnexpr;
                }
                else
                    break;
            }
        }
 
        result = lappend(result, expr);
    }
 
    return result;
}

References count_rowexpr_columns(), ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_INSERT_TARGET, exprLocation(), forthree, ResTarget::indirection, IsA, lappend(), lfirst, lfirst_int, lfirst_node, linitial, list_length(), list_nth(), ResTarget::location, ResTarget::name, FieldStore::newvals, NIL, parser_errposition(), SubscriptingRef::refassgnexpr, and transformAssignedExpr().

Referenced by transformInsertStmt(), and transformMergeStmt().

transformInsertStmt()

static Query * transformInsertStmt ( ParseState *  pstate, InsertStmt *  stmt  )

static

Definition at line 705 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    SelectStmt *selectStmt = (SelectStmt *) stmt->selectStmt;
    List       *exprList = NIL;
    bool        isGeneralSelect;
    List       *sub_rtable;
    List       *sub_rteperminfos;
    List       *sub_namespace;
    List       *icolumns;
    List       *attrnos;
    ParseNamespaceItem *nsitem;
    RTEPermissionInfo *perminfo;
    ListCell   *icols;
    ListCell   *attnos;
    ListCell   *lc;
    bool        isOnConflictUpdate;
    AclMode     targetPerms;
 
    /* There can't be any outer WITH to worry about */
    Assert(pstate->p_ctenamespace == NIL);
 
    qry->commandType = CMD_INSERT;
    pstate->p_is_insert = true;
 
    /* process the WITH clause independently of all else */
    if (stmt->withClause)
    {
        qry->hasRecursive = stmt->withClause->recursive;
        qry->cteList = transformWithClause(pstate, stmt->withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    qry->override = stmt->override;
 
    isOnConflictUpdate = (stmt->onConflictClause &&
                          stmt->onConflictClause->action == ONCONFLICT_UPDATE);
 
    /*
     * We have three cases to deal with: DEFAULT VALUES (selectStmt == NULL),
     * VALUES list, or general SELECT input.  We special-case VALUES, both for
     * efficiency and so we can handle DEFAULT specifications.
     *
     * The grammar allows attaching ORDER BY, LIMIT, FOR UPDATE, or WITH to a
     * VALUES clause.  If we have any of those, treat it as a general SELECT;
     * so it will work, but you can't use DEFAULT items together with those.
     */
    isGeneralSelect = (selectStmt && (selectStmt->valuesLists == NIL ||
                                      selectStmt->sortClause != NIL ||
                                      selectStmt->limitOffset != NULL ||
                                      selectStmt->limitCount != NULL ||
                                      selectStmt->lockingClause != NIL ||
                                      selectStmt->withClause != NULL));
 
    /*
     * If a non-nil rangetable/namespace was passed in, and we are doing
     * INSERT/SELECT, arrange to pass the rangetable/rteperminfos/namespace
     * down to the SELECT.  This can only happen if we are inside a CREATE
     * RULE, and in that case we want the rule's OLD and NEW rtable entries to
     * appear as part of the SELECT's rtable, not as outer references for it.
     * (Kluge!) The SELECT's joinlist is not affected however.  We must do
     * this before adding the target table to the INSERT's rtable.
     */
    if (isGeneralSelect)
    {
        sub_rtable = pstate->p_rtable;
        pstate->p_rtable = NIL;
        sub_rteperminfos = pstate->p_rteperminfos;
        pstate->p_rteperminfos = NIL;
        sub_namespace = pstate->p_namespace;
        pstate->p_namespace = NIL;
    }
    else
    {
        sub_rtable = NIL;       /* not used, but keep compiler quiet */
        sub_rteperminfos = NIL;
        sub_namespace = NIL;
    }
 
    /*
     * Must get write lock on INSERT target table before scanning SELECT, else
     * we will grab the wrong kind of initial lock if the target table is also
     * mentioned in the SELECT part.  Note that the target table is not added
     * to the joinlist or namespace.
     */
    targetPerms = ACL_INSERT;
    if (isOnConflictUpdate)
        targetPerms |= ACL_UPDATE;
    qry->resultRelation = setTargetTable(pstate, stmt->relation,
                                         false, false, targetPerms);
 
    /* Validate stmt->cols list, or build default list if no list given */
    icolumns = checkInsertTargets(pstate, stmt->cols, &attrnos);
    Assert(list_length(icolumns) == list_length(attrnos));
 
    /*
     * Determine which variant of INSERT we have.
     */
    if (selectStmt == NULL)
    {
        /*
         * We have INSERT ... DEFAULT VALUES.  We can handle this case by
         * emitting an empty targetlist --- all columns will be defaulted when
         * the planner expands the targetlist.
         */
        exprList = NIL;
    }
    else if (isGeneralSelect)
    {
        /*
         * We make the sub-pstate a child of the outer pstate so that it can
         * see any Param definitions supplied from above.  Since the outer
         * pstate's rtable and namespace are presently empty, there are no
         * side-effects of exposing names the sub-SELECT shouldn't be able to
         * see.
         */
        ParseState *sub_pstate = make_parsestate(pstate);
        Query      *selectQuery;
 
        /*
         * Process the source SELECT.
         *
         * It is important that this be handled just like a standalone SELECT;
         * otherwise the behavior of SELECT within INSERT might be different
         * from a stand-alone SELECT. (Indeed, Postgres up through 6.5 had
         * bugs of just that nature...)
         *
         * The sole exception is that we prevent resolving unknown-type
         * outputs as TEXT.  This does not change the semantics since if the
         * column type matters semantically, it would have been resolved to
         * something else anyway.  Doing this lets us resolve such outputs as
         * the target column's type, which we handle below.
         */
        sub_pstate->p_rtable = sub_rtable;
        sub_pstate->p_rteperminfos = sub_rteperminfos;
        sub_pstate->p_joinexprs = NIL;  /* sub_rtable has no joins */
        sub_pstate->p_nullingrels = NIL;
        sub_pstate->p_namespace = sub_namespace;
        sub_pstate->p_resolve_unknowns = false;
 
        selectQuery = transformStmt(sub_pstate, stmt->selectStmt);
 
        free_parsestate(sub_pstate);
 
        /* The grammar should have produced a SELECT */
        if (!IsA(selectQuery, Query) ||
            selectQuery->commandType != CMD_SELECT)
            elog(ERROR, "unexpected non-SELECT command in INSERT ... SELECT");
 
        /*
         * Make the source be a subquery in the INSERT's rangetable, and add
         * it to the INSERT's joinlist (but not the namespace).
         */
        nsitem = addRangeTableEntryForSubquery(pstate,
                                               selectQuery,
                                               makeAlias("*SELECT*", NIL),
                                               false,
                                               false);
        addNSItemToQuery(pstate, nsitem, true, false, false);
 
        /*----------
         * Generate an expression list for the INSERT that selects all the
         * non-resjunk columns from the subquery.  (INSERT's tlist must be
         * separate from the subquery's tlist because we may add columns,
         * insert datatype coercions, etc.)
         *
         * HACK: unknown-type constants and params in the SELECT's targetlist
         * are copied up as-is rather than being referenced as subquery
         * outputs.  This is to ensure that when we try to coerce them to
         * the target column's datatype, the right things happen (see
         * special cases in coerce_type).  Otherwise, this fails:
         *      INSERT INTO foo SELECT 'bar', ... FROM baz
         *----------
         */
        exprList = NIL;
        foreach(lc, selectQuery->targetList)
        {
            TargetEntry *tle = (TargetEntry *) lfirst(lc);
            Expr       *expr;
 
            if (tle->resjunk)
                continue;
            if (tle->expr &&
                (IsA(tle->expr, Const) || IsA(tle->expr, Param)) &&
                exprType((Node *) tle->expr) == UNKNOWNOID)
                expr = tle->expr;
            else
            {
                Var        *var = makeVarFromTargetEntry(nsitem->p_rtindex, tle);
 
                var->location = exprLocation((Node *) tle->expr);
                expr = (Expr *) var;
            }
            exprList = lappend(exprList, expr);
        }
 
        /* Prepare row for assignment to target table */
        exprList = transformInsertRow(pstate, exprList,
                                      stmt->cols,
                                      icolumns, attrnos,
                                      false);
    }
    else if (list_length(selectStmt->valuesLists) > 1)
    {
        /*
         * Process INSERT ... VALUES with multiple VALUES sublists. We
         * generate a VALUES RTE holding the transformed expression lists, and
         * build up a targetlist containing Vars that reference the VALUES
         * RTE.
         */
        List       *exprsLists = NIL;
        List       *coltypes = NIL;
        List       *coltypmods = NIL;
        List       *colcollations = NIL;
        int         sublist_length = -1;
        bool        lateral = false;
 
        Assert(selectStmt->intoClause == NULL);
 
        foreach(lc, selectStmt->valuesLists)
        {
            List       *sublist = (List *) lfirst(lc);
 
            /*
             * Do basic expression transformation (same as a ROW() expr, but
             * allow SetToDefault at top level)
             */
            sublist = transformExpressionList(pstate, sublist,
                                              EXPR_KIND_VALUES, true);
 
            /*
             * All the sublists must be the same length, *after*
             * transformation (which might expand '*' into multiple items).
             * The VALUES RTE can't handle anything different.
             */
            if (sublist_length < 0)
            {
                /* Remember post-transformation length of first sublist */
                sublist_length = list_length(sublist);
            }
            else if (sublist_length != list_length(sublist))
            {
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                         errmsg("VALUES lists must all be the same length"),
                         parser_errposition(pstate,
                                            exprLocation((Node *) sublist))));
            }
 
            /*
             * Prepare row for assignment to target table.  We process any
             * indirection on the target column specs normally but then strip
             * off the resulting field/array assignment nodes, since we don't
             * want the parsed statement to contain copies of those in each
             * VALUES row.  (It's annoying to have to transform the
             * indirection specs over and over like this, but avoiding it
             * would take some really messy refactoring of
             * transformAssignmentIndirection.)
             */
            sublist = transformInsertRow(pstate, sublist,
                                         stmt->cols,
                                         icolumns, attrnos,
                                         true);
 
            /*
             * We must assign collations now because assign_query_collations
             * doesn't process rangetable entries.  We just assign all the
             * collations independently in each row, and don't worry about
             * whether they are consistent vertically.  The outer INSERT query
             * isn't going to care about the collations of the VALUES columns,
             * so it's not worth the effort to identify a common collation for
             * each one here.  (But note this does have one user-visible
             * consequence: INSERT ... VALUES won't complain about conflicting
             * explicit COLLATEs in a column, whereas the same VALUES
             * construct in another context would complain.)
             */
            assign_list_collations(pstate, sublist);
 
            exprsLists = lappend(exprsLists, sublist);
        }
 
        /*
         * Construct column type/typmod/collation lists for the VALUES RTE.
         * Every expression in each column has been coerced to the type/typmod
         * of the corresponding target column or subfield, so it's sufficient
         * to look at the exprType/exprTypmod of the first row.  We don't care
         * about the collation labeling, so just fill in InvalidOid for that.
         */
        foreach(lc, (List *) linitial(exprsLists))
        {
            Node       *val = (Node *) lfirst(lc);
 
            coltypes = lappend_oid(coltypes, exprType(val));
            coltypmods = lappend_int(coltypmods, exprTypmod(val));
            colcollations = lappend_oid(colcollations, InvalidOid);
        }
 
        /*
         * Ordinarily there can't be any current-level Vars in the expression
         * lists, because the namespace was empty ... but if we're inside
         * CREATE RULE, then NEW/OLD references might appear.  In that case we
         * have to mark the VALUES RTE as LATERAL.
         */
        if (list_length(pstate->p_rtable) != 1 &&
            contain_vars_of_level((Node *) exprsLists, 0))
            lateral = true;
 
        /*
         * Generate the VALUES RTE
         */
        nsitem = addRangeTableEntryForValues(pstate, exprsLists,
                                             coltypes, coltypmods, colcollations,
                                             NULL, lateral, true);
        addNSItemToQuery(pstate, nsitem, true, false, false);
 
        /*
         * Generate list of Vars referencing the RTE
         */
        exprList = expandNSItemVars(pstate, nsitem, 0, -1, NULL);
 
        /*
         * Re-apply any indirection on the target column specs to the Vars
         */
        exprList = transformInsertRow(pstate, exprList,
                                      stmt->cols,
                                      icolumns, attrnos,
                                      false);
    }
    else
    {
        /*
         * Process INSERT ... VALUES with a single VALUES sublist.  We treat
         * this case separately for efficiency.  The sublist is just computed
         * directly as the Query's targetlist, with no VALUES RTE.  So it
         * works just like a SELECT without any FROM.
         */
        List       *valuesLists = selectStmt->valuesLists;
 
        Assert(list_length(valuesLists) == 1);
        Assert(selectStmt->intoClause == NULL);
 
        /*
         * Do basic expression transformation (same as a ROW() expr, but allow
         * SetToDefault at top level)
         */
        exprList = transformExpressionList(pstate,
                                           (List *) linitial(valuesLists),
                                           EXPR_KIND_VALUES_SINGLE,
                                           true);
 
        /* Prepare row for assignment to target table */
        exprList = transformInsertRow(pstate, exprList,
                                      stmt->cols,
                                      icolumns, attrnos,
                                      false);
    }
 
    /*
     * Generate query's target list using the computed list of expressions.
     * Also, mark all the target columns as needing insert permissions.
     */
    perminfo = pstate->p_target_nsitem->p_perminfo;
    qry->targetList = NIL;
    Assert(list_length(exprList) <= list_length(icolumns));
    forthree(lc, exprList, icols, icolumns, attnos, attrnos)
    {
        Expr       *expr = (Expr *) lfirst(lc);
        ResTarget  *col = lfirst_node(ResTarget, icols);
        AttrNumber  attr_num = (AttrNumber) lfirst_int(attnos);
        TargetEntry *tle;
 
        tle = makeTargetEntry(expr,
                              attr_num,
                              col->name,
                              false);
        qry->targetList = lappend(qry->targetList, tle);
 
        perminfo->insertedCols = bms_add_member(perminfo->insertedCols,
                                                attr_num - FirstLowInvalidHeapAttributeNumber);
    }
 
    /*
     * If we have any clauses yet to process, set the query namespace to
     * contain only the target relation, removing any entries added in a
     * sub-SELECT or VALUES list.
     */
    if (stmt->onConflictClause || stmt->returningClause)
    {
        pstate->p_namespace = NIL;
        addNSItemToQuery(pstate, pstate->p_target_nsitem,
                         false, true, true);
    }
 
    /* Process ON CONFLICT, if any. */
    if (stmt->onConflictClause)
        qry->onConflict = transformOnConflictClause(pstate,
                                                    stmt->onConflictClause);
 
    /* Process RETURNING, if any. */
    if (stmt->returningClause)
        transformReturningClause(pstate, qry, stmt->returningClause,
                                 EXPR_KIND_RETURNING);
 
    /* done building the range table and jointree */
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
 
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasSubLinks = pstate->p_hasSubLinks;
 
    assign_query_collations(pstate, qry);
 
    return qry;
}

References ACL_INSERT, ACL_UPDATE, addNSItemToQuery(), addRangeTableEntryForSubquery(), Assert(), checkInsertTargets(), CMD_INSERT, CMD_SELECT, Query::commandType, Query::cteList, elog, ERROR, TargetEntry::expr, exprLocation(), exprType(), free_parsestate(), IsA, lappend(), lfirst, SelectStmt::limitCount, SelectStmt::limitOffset, list_length(), Var::location, SelectStmt::lockingClause, make_parsestate(), makeAlias(), makeNode, makeVarFromTargetEntry(), NIL, ONCONFLICT_UPDATE, ParseState::p_ctenamespace, ParseState::p_hasModifyingCTE, ParseState::p_is_insert, ParseState::p_joinexprs, ParseState::p_namespace, ParseState::p_nullingrels, ParseState::p_resolve_unknowns, ParseState::p_rtable, ParseState::p_rteperminfos, setTargetTable(), SelectStmt::sortClause, stmt, Query::targetList, transformInsertRow(), transformStmt(), transformWithClause(), SelectStmt::valuesLists, and SelectStmt::withClause.

Referenced by transformStmt().

transformLockingClause()

static void transformLockingClause ( ParseState *  pstate, Query *  qry, LockingClause *  lc, bool  pushedDown  )

static

Definition at line 3530 of file analyze.c.

{
    List       *lockedRels = lc->lockedRels;
    ListCell   *l;
    ListCell   *rt;
    Index       i;
    LockingClause *allrels;
 
    CheckSelectLocking(qry, lc->strength);
 
    /* make a clause we can pass down to subqueries to select all rels */
    allrels = makeNode(LockingClause);
    allrels->lockedRels = NIL;  /* indicates all rels */
    allrels->strength = lc->strength;
    allrels->waitPolicy = lc->waitPolicy;
 
    if (lockedRels == NIL)
    {
        /*
         * Lock all regular tables used in query and its subqueries.  We
         * examine inFromCl to exclude auto-added RTEs, particularly NEW/OLD
         * in rules.  This is a bit of an abuse of a mostly-obsolete flag, but
         * it's convenient.  We can't rely on the namespace mechanism that has
         * largely replaced inFromCl, since for example we need to lock
         * base-relation RTEs even if they are masked by upper joins.
         */
        i = 0;
        foreach(rt, qry->rtable)
        {
            RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
 
            ++i;
            if (!rte->inFromCl)
                continue;
            switch (rte->rtekind)
            {
                case RTE_RELATION:
                    {
                        RTEPermissionInfo *perminfo;
 
                        applyLockingClause(qry, i,
                                           lc->strength,
                                           lc->waitPolicy,
                                           pushedDown);
                        perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
                        perminfo->requiredPerms |= ACL_SELECT_FOR_UPDATE;
                    }
                    break;
                case RTE_SUBQUERY:
                    applyLockingClause(qry, i, lc->strength, lc->waitPolicy,
                                       pushedDown);
 
                    /*
                     * FOR UPDATE/SHARE of subquery is propagated to all of
                     * subquery's rels, too.  We could do this later (based on
                     * the marking of the subquery RTE) but it is convenient
                     * to have local knowledge in each query level about which
                     * rels need to be opened with RowShareLock.
                     */
                    transformLockingClause(pstate, rte->subquery,
                                           allrels, true);
                    break;
                default:
                    /* ignore JOIN, SPECIAL, FUNCTION, VALUES, CTE RTEs */
                    break;
            }
        }
    }
    else
    {
        /*
         * Lock just the named tables.  As above, we allow locking any base
         * relation regardless of alias-visibility rules, so we need to
         * examine inFromCl to exclude OLD/NEW.
         */
        foreach(l, lockedRels)
        {
            RangeVar   *thisrel = (RangeVar *) lfirst(l);
 
            /* For simplicity we insist on unqualified alias names here */
            if (thisrel->catalogname || thisrel->schemaname)
                ereport(ERROR,
                        (errcode(ERRCODE_SYNTAX_ERROR),
                /*------
                  translator: %s is a SQL row locking clause such as FOR UPDATE */
                         errmsg("%s must specify unqualified relation names",
                                LCS_asString(lc->strength)),
                         parser_errposition(pstate, thisrel->location)));
 
            i = 0;
            foreach(rt, qry->rtable)
            {
                RangeTblEntry *rte = (RangeTblEntry *) lfirst(rt);
                char       *rtename = rte->eref->aliasname;
 
                ++i;
                if (!rte->inFromCl)
                    continue;
 
                /*
                 * A join RTE without an alias is not visible as a relation
                 * name and needs to be skipped (otherwise it might hide a
                 * base relation with the same name), except if it has a USING
                 * alias, which *is* visible.
                 *
                 * Subquery and values RTEs without aliases are never visible
                 * as relation names and must always be skipped.
                 */
                if (rte->alias == NULL)
                {
                    if (rte->rtekind == RTE_JOIN)
                    {
                        if (rte->join_using_alias == NULL)
                            continue;
                        rtename = rte->join_using_alias->aliasname;
                    }
                    else if (rte->rtekind == RTE_SUBQUERY ||
                             rte->rtekind == RTE_VALUES)
                        continue;
                }
 
                if (strcmp(rtename, thisrel->relname) == 0)
                {
                    switch (rte->rtekind)
                    {
                        case RTE_RELATION:
                            {
                                RTEPermissionInfo *perminfo;
 
                                applyLockingClause(qry, i,
                                                   lc->strength,
                                                   lc->waitPolicy,
                                                   pushedDown);
                                perminfo = getRTEPermissionInfo(qry->rteperminfos, rte);
                                perminfo->requiredPerms |= ACL_SELECT_FOR_UPDATE;
                            }
                            break;
                        case RTE_SUBQUERY:
                            applyLockingClause(qry, i, lc->strength,
                                               lc->waitPolicy, pushedDown);
                            /* see comment above */
                            transformLockingClause(pstate, rte->subquery,
                                                   allrels, true);
                            break;
                        case RTE_JOIN:
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            /*------
                              translator: %s is a SQL row locking clause such as FOR UPDATE */
                                     errmsg("%s cannot be applied to a join",
                                            LCS_asString(lc->strength)),
                                     parser_errposition(pstate, thisrel->location)));
                            break;
                        case RTE_FUNCTION:
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            /*------
                              translator: %s is a SQL row locking clause such as FOR UPDATE */
                                     errmsg("%s cannot be applied to a function",
                                            LCS_asString(lc->strength)),
                                     parser_errposition(pstate, thisrel->location)));
                            break;
                        case RTE_TABLEFUNC:
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            /*------
                              translator: %s is a SQL row locking clause such as FOR UPDATE */
                                     errmsg("%s cannot be applied to a table function",
                                            LCS_asString(lc->strength)),
                                     parser_errposition(pstate, thisrel->location)));
                            break;
                        case RTE_VALUES:
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            /*------
                              translator: %s is a SQL row locking clause such as FOR UPDATE */
                                     errmsg("%s cannot be applied to VALUES",
                                            LCS_asString(lc->strength)),
                                     parser_errposition(pstate, thisrel->location)));
                            break;
                        case RTE_CTE:
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            /*------
                              translator: %s is a SQL row locking clause such as FOR UPDATE */
                                     errmsg("%s cannot be applied to a WITH query",
                                            LCS_asString(lc->strength)),
                                     parser_errposition(pstate, thisrel->location)));
                            break;
                        case RTE_NAMEDTUPLESTORE:
                            ereport(ERROR,
                                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                            /*------
                              translator: %s is a SQL row locking clause such as FOR UPDATE */
                                     errmsg("%s cannot be applied to a named tuplestore",
                                            LCS_asString(lc->strength)),
                                     parser_errposition(pstate, thisrel->location)));
                            break;
 
                            /* Shouldn't be possible to see RTE_RESULT here */
 
                        default:
                            elog(ERROR, "unrecognized RTE type: %d",
                                 (int) rte->rtekind);
                            break;
                    }
                    break;      /* out of foreach loop */
                }
            }
            if (rt == NULL)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_TABLE),
                /*------
                  translator: %s is a SQL row locking clause such as FOR UPDATE */
                         errmsg("relation \"%s\" in %s clause not found in FROM clause",
                                thisrel->relname,
                                LCS_asString(lc->strength)),
                         parser_errposition(pstate, thisrel->location)));
        }
    }
}

References ACL_SELECT_FOR_UPDATE, applyLockingClause(), RangeVar::catalogname, CheckSelectLocking(), elog, ereport, errcode(), ERRCODE_UNDEFINED_TABLE, errmsg(), ERROR, getRTEPermissionInfo(), i, LCS_asString(), lfirst, RangeVar::location, LockingClause::lockedRels, makeNode, NIL, parser_errposition(), RangeVar::relname, RTEPermissionInfo::requiredPerms, Query::rtable, RTE_CTE, RTE_FUNCTION, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeVar::schemaname, LockingClause::strength, RangeTblEntry::subquery, transformLockingClause(), and LockingClause::waitPolicy.

Referenced by transformLockingClause(), transformPLAssignStmt(), transformSelectStmt(), and transformSetOperationStmt().

transformOnConflictClause()

static OnConflictExpr * transformOnConflictClause ( ParseState *  pstate, OnConflictClause *  onConflictClause  )

static

Definition at line 1242 of file analyze.c.

{
    ParseNamespaceItem *exclNSItem = NULL;
    List       *arbiterElems;
    Node       *arbiterWhere;
    Oid         arbiterConstraint;
    List       *onConflictSet = NIL;
    Node       *onConflictWhere = NULL;
    int         exclRelIndex = 0;
    List       *exclRelTlist = NIL;
    OnConflictExpr *result;
 
    /*
     * If this is ON CONFLICT ... UPDATE, first create the range table entry
     * for the EXCLUDED pseudo relation, so that that will be present while
     * processing arbiter expressions.  (You can't actually reference it from
     * there, but this provides a useful error message if you try.)
     */
    if (onConflictClause->action == ONCONFLICT_UPDATE)
    {
        Relation    targetrel = pstate->p_target_relation;
        RangeTblEntry *exclRte;
 
        exclNSItem = addRangeTableEntryForRelation(pstate,
                                                   targetrel,
                                                   RowExclusiveLock,
                                                   makeAlias("excluded", NIL),
                                                   false, false);
        exclRte = exclNSItem->p_rte;
        exclRelIndex = exclNSItem->p_rtindex;
 
        /*
         * relkind is set to composite to signal that we're not dealing with
         * an actual relation, and no permission checks are required on it.
         * (We'll check the actual target relation, instead.)
         */
        exclRte->relkind = RELKIND_COMPOSITE_TYPE;
 
        /* Create EXCLUDED rel's targetlist for use by EXPLAIN */
        exclRelTlist = BuildOnConflictExcludedTargetlist(targetrel,
                                                         exclRelIndex);
    }
 
    /* Process the arbiter clause, ON CONFLICT ON (...) */
    transformOnConflictArbiter(pstate, onConflictClause, &arbiterElems,
                               &arbiterWhere, &arbiterConstraint);
 
    /* Process DO UPDATE */
    if (onConflictClause->action == ONCONFLICT_UPDATE)
    {
        /*
         * Expressions in the UPDATE targetlist need to be handled like UPDATE
         * not INSERT.  We don't need to save/restore this because all INSERT
         * expressions have been parsed already.
         */
        pstate->p_is_insert = false;
 
        /*
         * Add the EXCLUDED pseudo relation to the query namespace, making it
         * available in the UPDATE subexpressions.
         */
        addNSItemToQuery(pstate, exclNSItem, false, true, true);
 
        /*
         * Now transform the UPDATE subexpressions.
         */
        onConflictSet =
            transformUpdateTargetList(pstate, onConflictClause->targetList);
 
        onConflictWhere = transformWhereClause(pstate,
                                               onConflictClause->whereClause,
                                               EXPR_KIND_WHERE, "WHERE");
 
        /*
         * Remove the EXCLUDED pseudo relation from the query namespace, since
         * it's not supposed to be available in RETURNING.  (Maybe someday we
         * could allow that, and drop this step.)
         */
        Assert((ParseNamespaceItem *) llast(pstate->p_namespace) == exclNSItem);
        pstate->p_namespace = list_delete_last(pstate->p_namespace);
    }
 
    /* Finally, build ON CONFLICT DO [NOTHING | UPDATE] expression */
    result = makeNode(OnConflictExpr);
 
    result->action = onConflictClause->action;
    result->arbiterElems = arbiterElems;
    result->arbiterWhere = arbiterWhere;
    result->constraint = arbiterConstraint;
    result->onConflictSet = onConflictSet;
    result->onConflictWhere = onConflictWhere;
    result->exclRelIndex = exclRelIndex;
    result->exclRelTlist = exclRelTlist;
 
    return result;
}

References OnConflictClause::action, OnConflictExpr::action, addNSItemToQuery(), addRangeTableEntryForRelation(), OnConflictExpr::arbiterElems, OnConflictExpr::arbiterWhere, Assert(), BuildOnConflictExcludedTargetlist(), OnConflictExpr::constraint, OnConflictExpr::exclRelIndex, OnConflictExpr::exclRelTlist, EXPR_KIND_WHERE, list_delete_last(), llast, makeAlias(), makeNode, NIL, ONCONFLICT_UPDATE, OnConflictExpr::onConflictSet, OnConflictExpr::onConflictWhere, ParseState::p_is_insert, ParseState::p_namespace, ParseNamespaceItem::p_rte, ParseNamespaceItem::p_rtindex, ParseState::p_target_relation, RowExclusiveLock, OnConflictClause::targetList, transformOnConflictArbiter(), transformUpdateTargetList(), transformWhereClause(), and OnConflictClause::whereClause.

transformOptionalSelectInto()

static Query * transformOptionalSelectInto ( ParseState *  pstate, Node *  parseTree  )

static

Definition at line 352 of file analyze.c.

{
    if (IsA(parseTree, SelectStmt))
    {
        SelectStmt *stmt = (SelectStmt *) parseTree;
 
        /* If it's a set-operation tree, drill down to leftmost SelectStmt */
        while (stmt && stmt->op != SETOP_NONE)
            stmt = stmt->larg;
        Assert(stmt && IsA(stmt, SelectStmt) && stmt->larg == NULL);
 
        if (stmt->intoClause)
        {
            CreateTableAsStmt *ctas = makeNode(CreateTableAsStmt);
 
            ctas->query = parseTree;
            ctas->into = stmt->intoClause;
            ctas->objtype = OBJECT_TABLE;
            ctas->is_select_into = true;
 
            /*
             * Remove the intoClause from the SelectStmt.  This makes it safe
             * for transformSelectStmt to complain if it finds intoClause set
             * (implying that the INTO appeared in a disallowed place).
             */
            stmt->intoClause = NULL;
 
            parseTree = (Node *) ctas;
        }
    }
 
    return transformStmt(pstate, parseTree);
}

References Assert(), CreateTableAsStmt::into, CreateTableAsStmt::is_select_into, IsA, makeNode, OBJECT_TABLE, CreateTableAsStmt::objtype, CreateTableAsStmt::query, SETOP_NONE, stmt, and transformStmt().

Referenced by transformExplainStmt(), and transformTopLevelStmt().

transformPLAssignStmt()

static Query * transformPLAssignStmt ( ParseState *  pstate, PLAssignStmt *  stmt  )

static

Definition at line 2847 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    ColumnRef  *cref = makeNode(ColumnRef);
    List       *indirection = stmt->indirection;
    int         nnames = stmt->nnames;
    SelectStmt *sstmt = stmt->val;
    Node       *target;
    Oid         targettype;
    int32       targettypmod;
    Oid         targetcollation;
    List       *tlist;
    TargetEntry *tle;
    Oid         type_id;
    Node       *qual;
    ListCell   *l;
 
    /*
     * First, construct a ColumnRef for the target variable.  If the target
     * has more than one dotted name, we have to pull the extra names out of
     * the indirection list.
     */
    cref->fields = list_make1(makeString(stmt->name));
    cref->location = stmt->location;
    if (nnames > 1)
    {
        /* avoid munging the raw parsetree */
        indirection = list_copy(indirection);
        while (--nnames > 0 && indirection != NIL)
        {
            Node       *ind = (Node *) linitial(indirection);
 
            if (!IsA(ind, String))
                elog(ERROR, "invalid name count in PLAssignStmt");
            cref->fields = lappend(cref->fields, ind);
            indirection = list_delete_first(indirection);
        }
    }
 
    /*
     * Transform the target reference.  Typically we will get back a Param
     * node, but there's no reason to be too picky about its type.
     */
    target = transformExpr(pstate, (Node *) cref,
                           EXPR_KIND_UPDATE_TARGET);
    targettype = exprType(target);
    targettypmod = exprTypmod(target);
    targetcollation = exprCollation(target);
 
    /*
     * The rest mostly matches transformSelectStmt, except that we needn't
     * consider WITH or INTO, and we build a targetlist our own way.
     */
    qry->commandType = CMD_SELECT;
    pstate->p_is_insert = false;
 
    /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
    pstate->p_locking_clause = sstmt->lockingClause;
 
    /* make WINDOW info available for window functions, too */
    pstate->p_windowdefs = sstmt->windowClause;
 
    /* process the FROM clause */
    transformFromClause(pstate, sstmt->fromClause);
 
    /* initially transform the targetlist as if in SELECT */
    tlist = transformTargetList(pstate, sstmt->targetList,
                                EXPR_KIND_SELECT_TARGET);
 
    /* we should have exactly one targetlist item */
    if (list_length(tlist) != 1)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg_plural("assignment source returned %d column",
                               "assignment source returned %d columns",
                               list_length(tlist),
                               list_length(tlist))));
 
    tle = linitial_node(TargetEntry, tlist);
 
    /*
     * This next bit is similar to transformAssignedExpr; the key difference
     * is we use COERCION_PLPGSQL not COERCION_ASSIGNMENT.
     */
    type_id = exprType((Node *) tle->expr);
 
    pstate->p_expr_kind = EXPR_KIND_UPDATE_TARGET;
 
    if (indirection)
    {
        tle->expr = (Expr *)
            transformAssignmentIndirection(pstate,
                                           target,
                                           stmt->name,
                                           false,
                                           targettype,
                                           targettypmod,
                                           targetcollation,
                                           indirection,
                                           list_head(indirection),
                                           (Node *) tle->expr,
                                           COERCION_PLPGSQL,
                                           exprLocation(target));
    }
    else if (targettype != type_id &&
             (targettype == RECORDOID || ISCOMPLEX(targettype)) &&
             (type_id == RECORDOID || ISCOMPLEX(type_id)))
    {
        /*
         * Hack: do not let coerce_to_target_type() deal with inconsistent
         * composite types.  Just pass the expression result through as-is,
         * and let the PL/pgSQL executor do the conversion its way.  This is
         * rather bogus, but it's needed for backwards compatibility.
         */
    }
    else
    {
        /*
         * For normal non-qualified target column, do type checking and
         * coercion.
         */
        Node       *orig_expr = (Node *) tle->expr;
 
        tle->expr = (Expr *)
            coerce_to_target_type(pstate,
                                  orig_expr, type_id,
                                  targettype, targettypmod,
                                  COERCION_PLPGSQL,
                                  COERCE_IMPLICIT_CAST,
                                  -1);
        /* With COERCION_PLPGSQL, this error is probably unreachable */
        if (tle->expr == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("variable \"%s\" is of type %s"
                            " but expression is of type %s",
                            stmt->name,
                            format_type_be(targettype),
                            format_type_be(type_id)),
                     errhint("You will need to rewrite or cast the expression."),
                     parser_errposition(pstate, exprLocation(orig_expr))));
    }
 
    pstate->p_expr_kind = EXPR_KIND_NONE;
 
    qry->targetList = list_make1(tle);
 
    /* transform WHERE */
    qual = transformWhereClause(pstate, sstmt->whereClause,
                                EXPR_KIND_WHERE, "WHERE");
 
    /* initial processing of HAVING clause is much like WHERE clause */
    qry->havingQual = transformWhereClause(pstate, sstmt->havingClause,
                                           EXPR_KIND_HAVING, "HAVING");
 
    /*
     * Transform sorting/grouping stuff.  Do ORDER BY first because both
     * transformGroupClause and transformDistinctClause need the results. Note
     * that these functions can also change the targetList, so it's passed to
     * them by reference.
     */
    qry->sortClause = transformSortClause(pstate,
                                          sstmt->sortClause,
                                          &qry->targetList,
                                          EXPR_KIND_ORDER_BY,
                                          false /* allow SQL92 rules */ );
 
    qry->groupClause = transformGroupClause(pstate,
                                            sstmt->groupClause,
                                            &qry->groupingSets,
                                            &qry->targetList,
                                            qry->sortClause,
                                            EXPR_KIND_GROUP_BY,
                                            false /* allow SQL92 rules */ );
 
    if (sstmt->distinctClause == NIL)
    {
        qry->distinctClause = NIL;
        qry->hasDistinctOn = false;
    }
    else if (linitial(sstmt->distinctClause) == NULL)
    {
        /* We had SELECT DISTINCT */
        qry->distinctClause = transformDistinctClause(pstate,
                                                      &qry->targetList,
                                                      qry->sortClause,
                                                      false);
        qry->hasDistinctOn = false;
    }
    else
    {
        /* We had SELECT DISTINCT ON */
        qry->distinctClause = transformDistinctOnClause(pstate,
                                                        sstmt->distinctClause,
                                                        &qry->targetList,
                                                        qry->sortClause);
        qry->hasDistinctOn = true;
    }
 
    /* transform LIMIT */
    qry->limitOffset = transformLimitClause(pstate, sstmt->limitOffset,
                                            EXPR_KIND_OFFSET, "OFFSET",
                                            sstmt->limitOption);
    qry->limitCount = transformLimitClause(pstate, sstmt->limitCount,
                                           EXPR_KIND_LIMIT, "LIMIT",
                                           sstmt->limitOption);
    qry->limitOption = sstmt->limitOption;
 
    /* transform window clauses after we have seen all window functions */
    qry->windowClause = transformWindowDefinitions(pstate,
                                                   pstate->p_windowdefs,
                                                   &qry->targetList);
 
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
 
    qry->hasSubLinks = pstate->p_hasSubLinks;
    qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasAggs = pstate->p_hasAggs;
 
    foreach(l, sstmt->lockingClause)
    {
        transformLockingClause(pstate, qry,
                               (LockingClause *) lfirst(l), false);
    }
 
    assign_query_collations(pstate, qry);
 
    /* this must be done after collations, for reliable comparison of exprs */
    if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
        parseCheckAggregates(pstate, qry);
 
    return qry;
}

References assign_query_collations(), CMD_SELECT, COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_PLPGSQL, Query::commandType, Query::distinctClause, SelectStmt::distinctClause, elog, ereport, errcode(), errhint(), errmsg(), errmsg_plural(), ERROR, TargetEntry::expr, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_LIMIT, EXPR_KIND_NONE, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_SELECT_TARGET, EXPR_KIND_UPDATE_TARGET, EXPR_KIND_WHERE, exprCollation(), exprLocation(), exprType(), exprTypmod(), ColumnRef::fields, format_type_be(), SelectStmt::fromClause, Query::groupClause, SelectStmt::groupClause, Query::groupingSets, SelectStmt::havingClause, Query::havingQual, IsA, ISCOMPLEX, Query::jointree, lappend(), lfirst, Query::limitCount, SelectStmt::limitCount, Query::limitOffset, SelectStmt::limitOffset, Query::limitOption, SelectStmt::limitOption, linitial, linitial_node, list_copy(), list_delete_first(), list_head(), list_length(), list_make1, ColumnRef::location, SelectStmt::lockingClause, makeFromExpr(), makeNode, makeString(), NIL, ParseState::p_expr_kind, ParseState::p_hasAggs, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_is_insert, ParseState::p_joinlist, ParseState::p_locking_clause, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_windowdefs, parseCheckAggregates(), parser_errposition(), Query::rtable, Query::sortClause, SelectStmt::sortClause, stmt, Query::targetList, SelectStmt::targetList, transformAssignmentIndirection(), transformDistinctClause(), transformDistinctOnClause(), transformExpr(), transformFromClause(), transformGroupClause(), transformLimitClause(), transformLockingClause(), transformSortClause(), transformTargetList(), transformWhereClause(), transformWindowDefinitions(), SelectStmt::whereClause, Query::windowClause, and SelectStmt::windowClause.

Referenced by transformStmt().

transformReturningClause()

void transformReturningClause	(	ParseState *	pstate,
		Query *	qry,
		ReturningClause *	returningClause,
		ParseExprKind	exprKind
	)

Definition at line 2725 of file analyze.c.

{
    int         save_nslen = list_length(pstate->p_namespace);
    int         save_next_resno;
 
    if (returningClause == NULL)
        return;                 /* nothing to do */
 
    /*
     * Scan RETURNING WITH(...) options for OLD/NEW alias names.  Complain if
     * there is any conflict with existing relations.
     */
    foreach_node(ReturningOption, option, returningClause->options)
    {
        switch (option->option)
        {
            case RETURNING_OPTION_OLD:
                if (qry->returningOldAlias != NULL)
                    ereport(ERROR,
                            errcode(ERRCODE_SYNTAX_ERROR),
                    /* translator: %s is OLD or NEW */
                            errmsg("%s cannot be specified multiple times", "OLD"),
                            parser_errposition(pstate, option->location));
                qry->returningOldAlias = option->value;
                break;
 
            case RETURNING_OPTION_NEW:
                if (qry->returningNewAlias != NULL)
                    ereport(ERROR,
                            errcode(ERRCODE_SYNTAX_ERROR),
                    /* translator: %s is OLD or NEW */
                            errmsg("%s cannot be specified multiple times", "NEW"),
                            parser_errposition(pstate, option->location));
                qry->returningNewAlias = option->value;
                break;
 
            default:
                elog(ERROR, "unrecognized returning option: %d", option->option);
        }
 
        if (refnameNamespaceItem(pstate, NULL, option->value, -1, NULL) != NULL)
            ereport(ERROR,
                    errcode(ERRCODE_DUPLICATE_ALIAS),
                    errmsg("table name \"%s\" specified more than once",
                           option->value),
                    parser_errposition(pstate, option->location));
 
        addNSItemForReturning(pstate, option->value,
                              option->option == RETURNING_OPTION_OLD ?
                              VAR_RETURNING_OLD : VAR_RETURNING_NEW);
    }
 
    /*
     * If OLD/NEW alias names weren't explicitly specified, use "old"/"new"
     * unless masked by existing relations.
     */
    if (qry->returningOldAlias == NULL &&
        refnameNamespaceItem(pstate, NULL, "old", -1, NULL) == NULL)
    {
        qry->returningOldAlias = "old";
        addNSItemForReturning(pstate, "old", VAR_RETURNING_OLD);
    }
    if (qry->returningNewAlias == NULL &&
        refnameNamespaceItem(pstate, NULL, "new", -1, NULL) == NULL)
    {
        qry->returningNewAlias = "new";
        addNSItemForReturning(pstate, "new", VAR_RETURNING_NEW);
    }
 
    /*
     * We need to assign resnos starting at one in the RETURNING list. Save
     * and restore the main tlist's value of p_next_resno, just in case
     * someone looks at it later (probably won't happen).
     */
    save_next_resno = pstate->p_next_resno;
    pstate->p_next_resno = 1;
 
    /* transform RETURNING expressions identically to a SELECT targetlist */
    qry->returningList = transformTargetList(pstate,
                                             returningClause->exprs,
                                             exprKind);
 
    /*
     * Complain if the nonempty tlist expanded to nothing (which is possible
     * if it contains only a star-expansion of a zero-column table).  If we
     * allow this, the parsed Query will look like it didn't have RETURNING,
     * with results that would probably surprise the user.
     */
    if (qry->returningList == NIL)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("RETURNING must have at least one column"),
                 parser_errposition(pstate,
                                    exprLocation(linitial(returningClause->exprs)))));
 
    /* mark column origins */
    markTargetListOrigins(pstate, qry->returningList);
 
    /* resolve any still-unresolved output columns as being type text */
    if (pstate->p_resolve_unknowns)
        resolveTargetListUnknowns(pstate, qry->returningList);
 
    /* restore state */
    pstate->p_namespace = list_truncate(pstate->p_namespace, save_nslen);
    pstate->p_next_resno = save_next_resno;
}

References addNSItemForReturning(), elog, ereport, errcode(), errmsg(), ERROR, exprLocation(), ReturningClause::exprs, foreach_node, linitial, list_length(), list_truncate(), markTargetListOrigins(), NIL, ReturningClause::options, ParseState::p_namespace, ParseState::p_next_resno, ParseState::p_resolve_unknowns, parser_errposition(), refnameNamespaceItem(), resolveTargetListUnknowns(), RETURNING_OPTION_NEW, RETURNING_OPTION_OLD, Query::returningList, transformTargetList(), VAR_RETURNING_NEW, and VAR_RETURNING_OLD.

Referenced by transformDeleteStmt(), transformMergeStmt(), and transformUpdateStmt().

transformReturnStmt()

static Query * transformReturnStmt ( ParseState *  pstate, ReturnStmt *  stmt  )

static

Definition at line 2513 of file analyze.c.

{
    Query      *qry = makeNode(Query);
 
    qry->commandType = CMD_SELECT;
    qry->isReturn = true;
 
    qry->targetList = list_make1(makeTargetEntry((Expr *) transformExpr(pstate, stmt->returnval, EXPR_KIND_SELECT_TARGET),
                                                 1, NULL, false));
 
    if (pstate->p_resolve_unknowns)
        resolveTargetListUnknowns(pstate, qry->targetList);
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
    qry->hasSubLinks = pstate->p_hasSubLinks;
    qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasAggs = pstate->p_hasAggs;
 
    assign_query_collations(pstate, qry);
 
    return qry;
}

References assign_query_collations(), CMD_SELECT, Query::commandType, EXPR_KIND_SELECT_TARGET, Query::jointree, list_make1, makeFromExpr(), makeNode, makeTargetEntry(), ParseState::p_hasAggs, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseState::p_resolve_unknowns, ParseState::p_rtable, ParseState::p_rteperminfos, resolveTargetListUnknowns(), Query::rtable, stmt, Query::targetList, and transformExpr().

Referenced by transformStmt().

transformSelectStmt()

static Query * transformSelectStmt ( ParseState *  pstate, SelectStmt *  stmt  )

static

Definition at line 1461 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    Node       *qual;
    ListCell   *l;
 
    qry->commandType = CMD_SELECT;
 
    /* process the WITH clause independently of all else */
    if (stmt->withClause)
    {
        qry->hasRecursive = stmt->withClause->recursive;
        qry->cteList = transformWithClause(pstate, stmt->withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    /* Complain if we get called from someplace where INTO is not allowed */
    if (stmt->intoClause)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("SELECT ... INTO is not allowed here"),
                 parser_errposition(pstate,
                                    exprLocation((Node *) stmt->intoClause))));
 
    /* make FOR UPDATE/FOR SHARE info available to addRangeTableEntry */
    pstate->p_locking_clause = stmt->lockingClause;
 
    /* make WINDOW info available for window functions, too */
    pstate->p_windowdefs = stmt->windowClause;
 
    /* process the FROM clause */
    transformFromClause(pstate, stmt->fromClause);
 
    /* transform targetlist */
    qry->targetList = transformTargetList(pstate, stmt->targetList,
                                          EXPR_KIND_SELECT_TARGET);
 
    /* mark column origins */
    markTargetListOrigins(pstate, qry->targetList);
 
    /* transform WHERE */
    qual = transformWhereClause(pstate, stmt->whereClause,
                                EXPR_KIND_WHERE, "WHERE");
 
    /* initial processing of HAVING clause is much like WHERE clause */
    qry->havingQual = transformWhereClause(pstate, stmt->havingClause,
                                           EXPR_KIND_HAVING, "HAVING");
 
    /*
     * Transform sorting/grouping stuff.  Do ORDER BY first because both
     * transformGroupClause and transformDistinctClause need the results. Note
     * that these functions can also change the targetList, so it's passed to
     * them by reference.
     */
    qry->sortClause = transformSortClause(pstate,
                                          stmt->sortClause,
                                          &qry->targetList,
                                          EXPR_KIND_ORDER_BY,
                                          false /* allow SQL92 rules */ );
 
    qry->groupClause = transformGroupClause(pstate,
                                            stmt->groupClause,
                                            &qry->groupingSets,
                                            &qry->targetList,
                                            qry->sortClause,
                                            EXPR_KIND_GROUP_BY,
                                            false /* allow SQL92 rules */ );
    qry->groupDistinct = stmt->groupDistinct;
 
    if (stmt->distinctClause == NIL)
    {
        qry->distinctClause = NIL;
        qry->hasDistinctOn = false;
    }
    else if (linitial(stmt->distinctClause) == NULL)
    {
        /* We had SELECT DISTINCT */
        qry->distinctClause = transformDistinctClause(pstate,
                                                      &qry->targetList,
                                                      qry->sortClause,
                                                      false);
        qry->hasDistinctOn = false;
    }
    else
    {
        /* We had SELECT DISTINCT ON */
        qry->distinctClause = transformDistinctOnClause(pstate,
                                                        stmt->distinctClause,
                                                        &qry->targetList,
                                                        qry->sortClause);
        qry->hasDistinctOn = true;
    }
 
    /* transform LIMIT */
    qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
                                            EXPR_KIND_OFFSET, "OFFSET",
                                            stmt->limitOption);
    qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
                                           EXPR_KIND_LIMIT, "LIMIT",
                                           stmt->limitOption);
    qry->limitOption = stmt->limitOption;
 
    /* transform window clauses after we have seen all window functions */
    qry->windowClause = transformWindowDefinitions(pstate,
                                                   pstate->p_windowdefs,
                                                   &qry->targetList);
 
    /* resolve any still-unresolved output columns as being type text */
    if (pstate->p_resolve_unknowns)
        resolveTargetListUnknowns(pstate, qry->targetList);
 
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
 
    qry->hasSubLinks = pstate->p_hasSubLinks;
    qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasAggs = pstate->p_hasAggs;
 
    foreach(l, stmt->lockingClause)
    {
        transformLockingClause(pstate, qry,
                               (LockingClause *) lfirst(l), false);
    }
 
    assign_query_collations(pstate, qry);
 
    /* this must be done after collations, for reliable comparison of exprs */
    if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
        parseCheckAggregates(pstate, qry);
 
    return qry;
}

References assign_query_collations(), CMD_SELECT, Query::commandType, Query::cteList, Query::distinctClause, ereport, errcode(), errmsg(), ERROR, EXPR_KIND_GROUP_BY, EXPR_KIND_HAVING, EXPR_KIND_LIMIT, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_SELECT_TARGET, EXPR_KIND_WHERE, exprLocation(), Query::groupClause, Query::groupDistinct, Query::groupingSets, Query::havingQual, Query::jointree, lfirst, Query::limitCount, Query::limitOffset, Query::limitOption, linitial, makeFromExpr(), makeNode, markTargetListOrigins(), NIL, ParseState::p_hasAggs, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseState::p_locking_clause, ParseState::p_resolve_unknowns, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_windowdefs, parseCheckAggregates(), parser_errposition(), resolveTargetListUnknowns(), Query::rtable, Query::sortClause, stmt, Query::targetList, transformDistinctClause(), transformDistinctOnClause(), transformFromClause(), transformGroupClause(), transformLimitClause(), transformLockingClause(), transformSortClause(), transformTargetList(), transformWhereClause(), transformWindowDefinitions(), transformWithClause(), and Query::windowClause.

Referenced by transformStmt().

transformSetOperationStmt()

static Query * transformSetOperationStmt ( ParseState *  pstate, SelectStmt *  stmt  )

static

Definition at line 1823 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    SelectStmt *leftmostSelect;
    int         leftmostRTI;
    Query      *leftmostQuery;
    SetOperationStmt *sostmt;
    List       *sortClause;
    Node       *limitOffset;
    Node       *limitCount;
    List       *lockingClause;
    WithClause *withClause;
    Node       *node;
    ListCell   *left_tlist,
               *lct,
               *lcm,
               *lcc,
               *l;
    List       *targetvars,
               *targetnames,
               *sv_namespace;
    int         sv_rtable_length;
    ParseNamespaceItem *jnsitem;
    ParseNamespaceColumn *sortnscolumns;
    int         sortcolindex;
    int         tllen;
 
    qry->commandType = CMD_SELECT;
 
    /*
     * Find leftmost leaf SelectStmt.  We currently only need to do this in
     * order to deliver a suitable error message if there's an INTO clause
     * there, implying the set-op tree is in a context that doesn't allow
     * INTO.  (transformSetOperationTree would throw error anyway, but it
     * seems worth the trouble to throw a different error for non-leftmost
     * INTO, so we produce that error in transformSetOperationTree.)
     */
    leftmostSelect = stmt->larg;
    while (leftmostSelect && leftmostSelect->op != SETOP_NONE)
        leftmostSelect = leftmostSelect->larg;
    Assert(leftmostSelect && IsA(leftmostSelect, SelectStmt) &&
           leftmostSelect->larg == NULL);
    if (leftmostSelect->intoClause)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("SELECT ... INTO is not allowed here"),
                 parser_errposition(pstate,
                                    exprLocation((Node *) leftmostSelect->intoClause))));
 
    /*
     * We need to extract ORDER BY and other top-level clauses here and not
     * let transformSetOperationTree() see them --- else it'll just recurse
     * right back here!
     */
    sortClause = stmt->sortClause;
    limitOffset = stmt->limitOffset;
    limitCount = stmt->limitCount;
    lockingClause = stmt->lockingClause;
    withClause = stmt->withClause;
 
    stmt->sortClause = NIL;
    stmt->limitOffset = NULL;
    stmt->limitCount = NULL;
    stmt->lockingClause = NIL;
    stmt->withClause = NULL;
 
    /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
    if (lockingClause)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
                        LCS_asString(((LockingClause *)
                                      linitial(lockingClause))->strength))));
 
    /* Process the WITH clause independently of all else */
    if (withClause)
    {
        qry->hasRecursive = withClause->recursive;
        qry->cteList = transformWithClause(pstate, withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    /*
     * Recursively transform the components of the tree.
     */
    sostmt = castNode(SetOperationStmt,
                      transformSetOperationTree(pstate, stmt, true, NULL));
    Assert(sostmt);
    qry->setOperations = (Node *) sostmt;
 
    /*
     * Re-find leftmost SELECT (now it's a sub-query in rangetable)
     */
    node = sostmt->larg;
    while (node && IsA(node, SetOperationStmt))
        node = ((SetOperationStmt *) node)->larg;
    Assert(node && IsA(node, RangeTblRef));
    leftmostRTI = ((RangeTblRef *) node)->rtindex;
    leftmostQuery = rt_fetch(leftmostRTI, pstate->p_rtable)->subquery;
    Assert(leftmostQuery != NULL);
 
    /*
     * Generate dummy targetlist for outer query using column names of
     * leftmost select and common datatypes/collations of topmost set
     * operation.  Also make lists of the dummy vars and their names for use
     * in parsing ORDER BY.
     *
     * Note: we use leftmostRTI as the varno of the dummy variables. It
     * shouldn't matter too much which RT index they have, as long as they
     * have one that corresponds to a real RT entry; else funny things may
     * happen when the tree is mashed by rule rewriting.
     */
    qry->targetList = NIL;
    targetvars = NIL;
    targetnames = NIL;
    sortnscolumns = (ParseNamespaceColumn *)
        palloc0(list_length(sostmt->colTypes) * sizeof(ParseNamespaceColumn));
    sortcolindex = 0;
 
    forfour(lct, sostmt->colTypes,
            lcm, sostmt->colTypmods,
            lcc, sostmt->colCollations,
            left_tlist, leftmostQuery->targetList)
    {
        Oid         colType = lfirst_oid(lct);
        int32       colTypmod = lfirst_int(lcm);
        Oid         colCollation = lfirst_oid(lcc);
        TargetEntry *lefttle = (TargetEntry *) lfirst(left_tlist);
        char       *colName;
        TargetEntry *tle;
        Var        *var;
 
        Assert(!lefttle->resjunk);
        colName = pstrdup(lefttle->resname);
        var = makeVar(leftmostRTI,
                      lefttle->resno,
                      colType,
                      colTypmod,
                      colCollation,
                      0);
        var->location = exprLocation((Node *) lefttle->expr);
        tle = makeTargetEntry((Expr *) var,
                              (AttrNumber) pstate->p_next_resno++,
                              colName,
                              false);
        qry->targetList = lappend(qry->targetList, tle);
        targetvars = lappend(targetvars, var);
        targetnames = lappend(targetnames, makeString(colName));
        sortnscolumns[sortcolindex].p_varno = leftmostRTI;
        sortnscolumns[sortcolindex].p_varattno = lefttle->resno;
        sortnscolumns[sortcolindex].p_vartype = colType;
        sortnscolumns[sortcolindex].p_vartypmod = colTypmod;
        sortnscolumns[sortcolindex].p_varcollid = colCollation;
        sortnscolumns[sortcolindex].p_varnosyn = leftmostRTI;
        sortnscolumns[sortcolindex].p_varattnosyn = lefttle->resno;
        sortcolindex++;
    }
 
    /*
     * As a first step towards supporting sort clauses that are expressions
     * using the output columns, generate a namespace entry that makes the
     * output columns visible.  A Join RTE node is handy for this, since we
     * can easily control the Vars generated upon matches.
     *
     * Note: we don't yet do anything useful with such cases, but at least
     * "ORDER BY upper(foo)" will draw the right error message rather than
     * "foo not found".
     */
    sv_rtable_length = list_length(pstate->p_rtable);
 
    jnsitem = addRangeTableEntryForJoin(pstate,
                                        targetnames,
                                        sortnscolumns,
                                        JOIN_INNER,
                                        0,
                                        targetvars,
                                        NIL,
                                        NIL,
                                        NULL,
                                        NULL,
                                        false);
 
    sv_namespace = pstate->p_namespace;
    pstate->p_namespace = NIL;
 
    /* add jnsitem to column namespace only */
    addNSItemToQuery(pstate, jnsitem, false, false, true);
 
    /*
     * For now, we don't support resjunk sort clauses on the output of a
     * setOperation tree --- you can only use the SQL92-spec options of
     * selecting an output column by name or number.  Enforce by checking that
     * transformSortClause doesn't add any items to tlist.  Note, if changing
     * this, add_setop_child_rel_equivalences() will need to be updated.
     */
    tllen = list_length(qry->targetList);
 
    qry->sortClause = transformSortClause(pstate,
                                          sortClause,
                                          &qry->targetList,
                                          EXPR_KIND_ORDER_BY,
                                          false /* allow SQL92 rules */ );
 
    /* restore namespace, remove join RTE from rtable */
    pstate->p_namespace = sv_namespace;
    pstate->p_rtable = list_truncate(pstate->p_rtable, sv_rtable_length);
 
    if (tllen != list_length(qry->targetList))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("invalid UNION/INTERSECT/EXCEPT ORDER BY clause"),
                 errdetail("Only result column names can be used, not expressions or functions."),
                 errhint("Add the expression/function to every SELECT, or move the UNION into a FROM clause."),
                 parser_errposition(pstate,
                                    exprLocation(list_nth(qry->targetList, tllen)))));
 
    qry->limitOffset = transformLimitClause(pstate, limitOffset,
                                            EXPR_KIND_OFFSET, "OFFSET",
                                            stmt->limitOption);
    qry->limitCount = transformLimitClause(pstate, limitCount,
                                           EXPR_KIND_LIMIT, "LIMIT",
                                           stmt->limitOption);
    qry->limitOption = stmt->limitOption;
 
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
 
    qry->hasSubLinks = pstate->p_hasSubLinks;
    qry->hasWindowFuncs = pstate->p_hasWindowFuncs;
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasAggs = pstate->p_hasAggs;
 
    foreach(l, lockingClause)
    {
        transformLockingClause(pstate, qry,
                               (LockingClause *) lfirst(l), false);
    }
 
    assign_query_collations(pstate, qry);
 
    /* this must be done after collations, for reliable comparison of exprs */
    if (pstate->p_hasAggs || qry->groupClause || qry->groupingSets || qry->havingQual)
        parseCheckAggregates(pstate, qry);
 
    return qry;
}

References addNSItemToQuery(), addRangeTableEntryForJoin(), Assert(), assign_query_collations(), castNode, CMD_SELECT, Query::commandType, Query::cteList, ereport, errcode(), errdetail(), errhint(), errmsg(), ERROR, TargetEntry::expr, EXPR_KIND_LIMIT, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, exprLocation(), forfour, Query::groupClause, Query::groupingSets, Query::havingQual, SelectStmt::intoClause, IsA, JOIN_INNER, Query::jointree, lappend(), SelectStmt::larg, SetOperationStmt::larg, LCS_asString(), lfirst, lfirst_int, lfirst_oid, Query::limitCount, Query::limitOffset, Query::limitOption, linitial, list_length(), list_nth(), list_truncate(), Var::location, makeFromExpr(), makeNode, makeString(), makeTargetEntry(), makeVar(), NIL, SelectStmt::op, ParseState::p_hasAggs, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_hasWindowFuncs, ParseState::p_joinlist, ParseState::p_namespace, ParseState::p_next_resno, ParseState::p_rtable, ParseState::p_rteperminfos, ParseNamespaceColumn::p_varattno, ParseNamespaceColumn::p_varattnosyn, ParseNamespaceColumn::p_varcollid, ParseNamespaceColumn::p_varno, ParseNamespaceColumn::p_varnosyn, ParseNamespaceColumn::p_vartype, ParseNamespaceColumn::p_vartypmod, palloc0(), parseCheckAggregates(), parser_errposition(), pstrdup(), WithClause::recursive, TargetEntry::resno, rt_fetch, Query::rtable, SETOP_NONE, Query::setOperations, Query::sortClause, stmt, Query::targetList, transformLimitClause(), transformLockingClause(), transformSetOperationTree(), transformSortClause(), and transformWithClause().

Referenced by transformStmt().

transformSetOperationTree()

static Node * transformSetOperationTree ( ParseState *  pstate, SelectStmt *  stmt, bool  isTopLevel, List **  targetlist  )

static

Definition at line 2128 of file analyze.c.

{
    bool        isLeaf;
 
    Assert(stmt && IsA(stmt, SelectStmt));
 
    /* Guard against stack overflow due to overly complex set-expressions */
    check_stack_depth();
 
    /*
     * Validity-check both leaf and internal SELECTs for disallowed ops.
     */
    if (stmt->intoClause)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("INTO is only allowed on first SELECT of UNION/INTERSECT/EXCEPT"),
                 parser_errposition(pstate,
                                    exprLocation((Node *) stmt->intoClause))));
 
    /* We don't support FOR UPDATE/SHARE with set ops at the moment. */
    if (stmt->lockingClause)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s is not allowed with UNION/INTERSECT/EXCEPT",
                        LCS_asString(((LockingClause *)
                                      linitial(stmt->lockingClause))->strength))));
 
    /*
     * If an internal node of a set-op tree has ORDER BY, LIMIT, FOR UPDATE,
     * or WITH clauses attached, we need to treat it like a leaf node to
     * generate an independent sub-Query tree.  Otherwise, it can be
     * represented by a SetOperationStmt node underneath the parent Query.
     */
    if (stmt->op == SETOP_NONE)
    {
        Assert(stmt->larg == NULL && stmt->rarg == NULL);
        isLeaf = true;
    }
    else
    {
        Assert(stmt->larg != NULL && stmt->rarg != NULL);
        if (stmt->sortClause || stmt->limitOffset || stmt->limitCount ||
            stmt->lockingClause || stmt->withClause)
            isLeaf = true;
        else
            isLeaf = false;
    }
 
    if (isLeaf)
    {
        /* Process leaf SELECT */
        Query      *selectQuery;
        char        selectName[32];
        ParseNamespaceItem *nsitem;
        RangeTblRef *rtr;
        ListCell   *tl;
 
        /*
         * Transform SelectStmt into a Query.
         *
         * This works the same as SELECT transformation normally would, except
         * that we prevent resolving unknown-type outputs as TEXT.  This does
         * not change the subquery's semantics since if the column type
         * matters semantically, it would have been resolved to something else
         * anyway.  Doing this lets us resolve such outputs using
         * select_common_type(), below.
         *
         * Note: previously transformed sub-queries don't affect the parsing
         * of this sub-query, because they are not in the toplevel pstate's
         * namespace list.
         */
        selectQuery = parse_sub_analyze((Node *) stmt, pstate,
                                        NULL, false, false);
 
        /*
         * Check for bogus references to Vars on the current query level (but
         * upper-level references are okay). Normally this can't happen
         * because the namespace will be empty, but it could happen if we are
         * inside a rule.
         */
        if (pstate->p_namespace)
        {
            if (contain_vars_of_level((Node *) selectQuery, 1))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
                         errmsg("UNION/INTERSECT/EXCEPT member statement cannot refer to other relations of same query level"),
                         parser_errposition(pstate,
                                            locate_var_of_level((Node *) selectQuery, 1))));
        }
 
        /*
         * Extract a list of the non-junk TLEs for upper-level processing.
         */
        if (targetlist)
        {
            *targetlist = NIL;
            foreach(tl, selectQuery->targetList)
            {
                TargetEntry *tle = (TargetEntry *) lfirst(tl);
 
                if (!tle->resjunk)
                    *targetlist = lappend(*targetlist, tle);
            }
        }
 
        /*
         * Make the leaf query be a subquery in the top-level rangetable.
         */
        snprintf(selectName, sizeof(selectName), "*SELECT* %d",
                 list_length(pstate->p_rtable) + 1);
        nsitem = addRangeTableEntryForSubquery(pstate,
                                               selectQuery,
                                               makeAlias(selectName, NIL),
                                               false,
                                               false);
 
        /*
         * Return a RangeTblRef to replace the SelectStmt in the set-op tree.
         */
        rtr = makeNode(RangeTblRef);
        rtr->rtindex = nsitem->p_rtindex;
        return (Node *) rtr;
    }
    else
    {
        /* Process an internal node (set operation node) */
        SetOperationStmt *op = makeNode(SetOperationStmt);
        List       *ltargetlist;
        List       *rtargetlist;
        ListCell   *ltl;
        ListCell   *rtl;
        const char *context;
        bool        recursive = (pstate->p_parent_cte &&
                                 pstate->p_parent_cte->cterecursive);
 
        context = (stmt->op == SETOP_UNION ? "UNION" :
                   (stmt->op == SETOP_INTERSECT ? "INTERSECT" :
                    "EXCEPT"));
 
        op->op = stmt->op;
        op->all = stmt->all;
 
        /*
         * Recursively transform the left child node.
         */
        op->larg = transformSetOperationTree(pstate, stmt->larg,
                                             false,
                                             &ltargetlist);
 
        /*
         * If we are processing a recursive union query, now is the time to
         * examine the non-recursive term's output columns and mark the
         * containing CTE as having those result columns.  We should do this
         * only at the topmost setop of the CTE, of course.
         */
        if (isTopLevel && recursive)
            determineRecursiveColTypes(pstate, op->larg, ltargetlist);
 
        /*
         * Recursively transform the right child node.
         */
        op->rarg = transformSetOperationTree(pstate, stmt->rarg,
                                             false,
                                             &rtargetlist);
 
        /*
         * Verify that the two children have the same number of non-junk
         * columns, and determine the types of the merged output columns.
         */
        if (list_length(ltargetlist) != list_length(rtargetlist))
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("each %s query must have the same number of columns",
                            context),
                     parser_errposition(pstate,
                                        exprLocation((Node *) rtargetlist))));
 
        if (targetlist)
            *targetlist = NIL;
        op->colTypes = NIL;
        op->colTypmods = NIL;
        op->colCollations = NIL;
        op->groupClauses = NIL;
        forboth(ltl, ltargetlist, rtl, rtargetlist)
        {
            TargetEntry *ltle = (TargetEntry *) lfirst(ltl);
            TargetEntry *rtle = (TargetEntry *) lfirst(rtl);
            Node       *lcolnode = (Node *) ltle->expr;
            Node       *rcolnode = (Node *) rtle->expr;
            Oid         lcoltype = exprType(lcolnode);
            Oid         rcoltype = exprType(rcolnode);
            Node       *bestexpr;
            int         bestlocation;
            Oid         rescoltype;
            int32       rescoltypmod;
            Oid         rescolcoll;
 
            /* select common type, same as CASE et al */
            rescoltype = select_common_type(pstate,
                                            list_make2(lcolnode, rcolnode),
                                            context,
                                            &bestexpr);
            bestlocation = exprLocation(bestexpr);
 
            /*
             * Verify the coercions are actually possible.  If not, we'd fail
             * later anyway, but we want to fail now while we have sufficient
             * context to produce an error cursor position.
             *
             * For all non-UNKNOWN-type cases, we verify coercibility but we
             * don't modify the child's expression, for fear of changing the
             * child query's semantics.
             *
             * If a child expression is an UNKNOWN-type Const or Param, we
             * want to replace it with the coerced expression.  This can only
             * happen when the child is a leaf set-op node.  It's safe to
             * replace the expression because if the child query's semantics
             * depended on the type of this output column, it'd have already
             * coerced the UNKNOWN to something else.  We want to do this
             * because (a) we want to verify that a Const is valid for the
             * target type, or resolve the actual type of an UNKNOWN Param,
             * and (b) we want to avoid unnecessary discrepancies between the
             * output type of the child query and the resolved target type.
             * Such a discrepancy would disable optimization in the planner.
             *
             * If it's some other UNKNOWN-type node, eg a Var, we do nothing
             * (knowing that coerce_to_common_type would fail).  The planner
             * is sometimes able to fold an UNKNOWN Var to a constant before
             * it has to coerce the type, so failing now would just break
             * cases that might work.
             */
            if (lcoltype != UNKNOWNOID)
                lcolnode = coerce_to_common_type(pstate, lcolnode,
                                                 rescoltype, context);
            else if (IsA(lcolnode, Const) ||
                     IsA(lcolnode, Param))
            {
                lcolnode = coerce_to_common_type(pstate, lcolnode,
                                                 rescoltype, context);
                ltle->expr = (Expr *) lcolnode;
            }
 
            if (rcoltype != UNKNOWNOID)
                rcolnode = coerce_to_common_type(pstate, rcolnode,
                                                 rescoltype, context);
            else if (IsA(rcolnode, Const) ||
                     IsA(rcolnode, Param))
            {
                rcolnode = coerce_to_common_type(pstate, rcolnode,
                                                 rescoltype, context);
                rtle->expr = (Expr *) rcolnode;
            }
 
            rescoltypmod = select_common_typmod(pstate,
                                                list_make2(lcolnode, rcolnode),
                                                rescoltype);
 
            /*
             * Select common collation.  A common collation is required for
             * all set operators except UNION ALL; see SQL:2008 7.13 <query
             * expression> Syntax Rule 15c.  (If we fail to identify a common
             * collation for a UNION ALL column, the colCollations element
             * will be set to InvalidOid, which may result in a runtime error
             * if something at a higher query level wants to use the column's
             * collation.)
             */
            rescolcoll = select_common_collation(pstate,
                                                 list_make2(lcolnode, rcolnode),
                                                 (op->op == SETOP_UNION && op->all));
 
            /* emit results */
            op->colTypes = lappend_oid(op->colTypes, rescoltype);
            op->colTypmods = lappend_int(op->colTypmods, rescoltypmod);
            op->colCollations = lappend_oid(op->colCollations, rescolcoll);
 
            /*
             * For all cases except UNION ALL, identify the grouping operators
             * (and, if available, sorting operators) that will be used to
             * eliminate duplicates.
             */
            if (op->op != SETOP_UNION || !op->all)
            {
                ParseCallbackState pcbstate;
 
                setup_parser_errposition_callback(&pcbstate, pstate,
                                                  bestlocation);
 
                /*
                 * If it's a recursive union, we need to require hashing
                 * support.
                 */
                op->groupClauses = lappend(op->groupClauses,
                                           makeSortGroupClauseForSetOp(rescoltype, recursive));
 
                cancel_parser_errposition_callback(&pcbstate);
            }
 
            /*
             * Construct a dummy tlist entry to return.  We use a SetToDefault
             * node for the expression, since it carries exactly the fields
             * needed, but any other expression node type would do as well.
             */
            if (targetlist)
            {
                SetToDefault *rescolnode = makeNode(SetToDefault);
                TargetEntry *restle;
 
                rescolnode->typeId = rescoltype;
                rescolnode->typeMod = rescoltypmod;
                rescolnode->collation = rescolcoll;
                rescolnode->location = bestlocation;
                restle = makeTargetEntry((Expr *) rescolnode,
                                         0, /* no need to set resno */
                                         NULL,
                                         false);
                *targetlist = lappend(*targetlist, restle);
            }
        }
 
        return (Node *) op;
    }
}

References addRangeTableEntryForSubquery(), SetOperationStmt::all, Assert(), cancel_parser_errposition_callback(), check_stack_depth(), coerce_to_common_type(), contain_vars_of_level(), determineRecursiveColTypes(), ereport, errcode(), errmsg(), ERROR, TargetEntry::expr, exprLocation(), exprType(), forboth, IsA, lappend(), lappend_int(), lappend_oid(), SetOperationStmt::larg, LCS_asString(), lfirst, linitial, list_length(), list_make2, locate_var_of_level(), SetToDefault::location, makeAlias(), makeNode, makeSortGroupClauseForSetOp(), makeTargetEntry(), NIL, SetOperationStmt::op, ParseState::p_namespace, ParseState::p_parent_cte, ParseState::p_rtable, ParseNamespaceItem::p_rtindex, parse_sub_analyze(), parser_errposition(), SetOperationStmt::rarg, RangeTblRef::rtindex, select_common_collation(), select_common_type(), select_common_typmod(), SETOP_INTERSECT, SETOP_NONE, SETOP_UNION, setup_parser_errposition_callback(), snprintf, stmt, Query::targetList, transformSetOperationTree(), and SetToDefault::typeId.

Referenced by transformSetOperationStmt(), and transformSetOperationTree().

transformStmt()

Query * transformStmt	(	ParseState *	pstate,
		Node *	parseTree
	)

Definition at line 391 of file analyze.c.

{
    Query      *result;
 
#ifdef DEBUG_NODE_TESTS_ENABLED
 
    /*
     * We apply debug_raw_expression_coverage_test testing to basic DML
     * statements; we can't just run it on everything because
     * raw_expression_tree_walker() doesn't claim to handle utility
     * statements.
     */
    if (Debug_raw_expression_coverage_test)
    {
        switch (nodeTag(parseTree))
        {
            case T_SelectStmt:
            case T_InsertStmt:
            case T_UpdateStmt:
            case T_DeleteStmt:
            case T_MergeStmt:
                (void) test_raw_expression_coverage(parseTree, NULL);
                break;
            default:
                break;
        }
    }
#endif                          /* DEBUG_NODE_TESTS_ENABLED */
 
    /*
     * Caution: when changing the set of statement types that have non-default
     * processing here, see also stmt_requires_parse_analysis() and
     * analyze_requires_snapshot().
     */
    switch (nodeTag(parseTree))
    {
            /*
             * Optimizable statements
             */
        case T_InsertStmt:
            result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
            break;
 
        case T_DeleteStmt:
            result = transformDeleteStmt(pstate, (DeleteStmt *) parseTree);
            break;
 
        case T_UpdateStmt:
            result = transformUpdateStmt(pstate, (UpdateStmt *) parseTree);
            break;
 
        case T_MergeStmt:
            result = transformMergeStmt(pstate, (MergeStmt *) parseTree);
            break;
 
        case T_SelectStmt:
            {
                SelectStmt *n = (SelectStmt *) parseTree;
 
                if (n->valuesLists)
                    result = transformValuesClause(pstate, n);
                else if (n->op == SETOP_NONE)
                    result = transformSelectStmt(pstate, n);
                else
                    result = transformSetOperationStmt(pstate, n);
            }
            break;
 
        case T_ReturnStmt:
            result = transformReturnStmt(pstate, (ReturnStmt *) parseTree);
            break;
 
        case T_PLAssignStmt:
            result = transformPLAssignStmt(pstate,
                                           (PLAssignStmt *) parseTree);
            break;
 
            /*
             * Special cases
             */
        case T_DeclareCursorStmt:
            result = transformDeclareCursorStmt(pstate,
                                                (DeclareCursorStmt *) parseTree);
            break;
 
        case T_ExplainStmt:
            result = transformExplainStmt(pstate,
                                          (ExplainStmt *) parseTree);
            break;
 
        case T_CreateTableAsStmt:
            result = transformCreateTableAsStmt(pstate,
                                                (CreateTableAsStmt *) parseTree);
            break;
 
        case T_CallStmt:
            result = transformCallStmt(pstate,
                                       (CallStmt *) parseTree);
            break;
 
        default:
 
            /*
             * other statements don't require any transformation; just return
             * the original parsetree with a Query node plastered on top.
             */
            result = makeNode(Query);
            result->commandType = CMD_UTILITY;
            result->utilityStmt = (Node *) parseTree;
            break;
    }
 
    /* Mark as original query until we learn differently */
    result->querySource = QSRC_ORIGINAL;
    result->canSetTag = true;
    setQueryLocationAndLength(pstate, result, parseTree);
 
    return result;
}

References CMD_UTILITY, Query::commandType, makeNode, nodeTag, SelectStmt::op, QSRC_ORIGINAL, SETOP_NONE, setQueryLocationAndLength(), transformCallStmt(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformDeleteStmt(), transformExplainStmt(), transformInsertStmt(), transformMergeStmt(), transformPLAssignStmt(), transformReturnStmt(), transformSelectStmt(), transformSetOperationStmt(), transformUpdateStmt(), transformValuesClause(), Query::utilityStmt, and SelectStmt::valuesLists.

Referenced by interpret_AS_clause(), parse_sub_analyze(), transformCreateTableAsStmt(), transformDeclareCursorStmt(), transformInsertStmt(), transformJsonArrayQueryConstructor(), transformOptionalSelectInto(), and transformRuleStmt().

transformTopLevelStmt()

Query * transformTopLevelStmt	(	ParseState *	pstate,
		RawStmt *	parseTree
	)

Definition at line 327 of file analyze.c.

{
    Query      *result;
 
    /* Store RawStmt's length and location in pstate */
    pstate->p_stmt_len = parseTree->stmt_len;
    pstate->p_stmt_location = parseTree->stmt_location;
 
    /* We're at top level, so allow SELECT INTO */
    result = transformOptionalSelectInto(pstate, parseTree->stmt);
 
    return result;
}

References ParseState::p_stmt_len, ParseState::p_stmt_location, RawStmt::stmt, RawStmt::stmt_len, RawStmt::stmt_location, and transformOptionalSelectInto().

Referenced by inline_function(), parse_analyze_fixedparams(), parse_analyze_varparams(), and parse_analyze_withcb().

transformUpdateStmt()

static Query * transformUpdateStmt ( ParseState *  pstate, UpdateStmt *  stmt  )

static

Definition at line 2544 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    ParseNamespaceItem *nsitem;
    Node       *qual;
 
    qry->commandType = CMD_UPDATE;
    pstate->p_is_insert = false;
 
    /* process the WITH clause independently of all else */
    if (stmt->withClause)
    {
        qry->hasRecursive = stmt->withClause->recursive;
        qry->cteList = transformWithClause(pstate, stmt->withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    qry->resultRelation = setTargetTable(pstate, stmt->relation,
                                         stmt->relation->inh,
                                         true,
                                         ACL_UPDATE);
    nsitem = pstate->p_target_nsitem;
 
    /* subqueries in FROM cannot access the result relation */
    nsitem->p_lateral_only = true;
    nsitem->p_lateral_ok = false;
 
    /*
     * the FROM clause is non-standard SQL syntax. We used to be able to do
     * this with REPLACE in POSTQUEL so we keep the feature.
     */
    transformFromClause(pstate, stmt->fromClause);
 
    /* remaining clauses can reference the result relation normally */
    nsitem->p_lateral_only = false;
    nsitem->p_lateral_ok = true;
 
    qual = transformWhereClause(pstate, stmt->whereClause,
                                EXPR_KIND_WHERE, "WHERE");
 
    transformReturningClause(pstate, qry, stmt->returningClause,
                             EXPR_KIND_RETURNING);
 
    /*
     * Now we are done with SELECT-like processing, and can get on with
     * transforming the target list to match the UPDATE target columns.
     */
    qry->targetList = transformUpdateTargetList(pstate, stmt->targetList);
 
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, qual);
 
    qry->hasTargetSRFs = pstate->p_hasTargetSRFs;
    qry->hasSubLinks = pstate->p_hasSubLinks;
 
    assign_query_collations(pstate, qry);
 
    return qry;
}

References ACL_UPDATE, assign_query_collations(), CMD_UPDATE, Query::commandType, Query::cteList, EXPR_KIND_RETURNING, EXPR_KIND_WHERE, Query::jointree, makeFromExpr(), makeNode, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_hasTargetSRFs, ParseState::p_is_insert, ParseState::p_joinlist, ParseNamespaceItem::p_lateral_ok, ParseNamespaceItem::p_lateral_only, ParseState::p_rtable, ParseState::p_rteperminfos, ParseState::p_target_nsitem, Query::rtable, setTargetTable(), stmt, Query::targetList, transformFromClause(), transformReturningClause(), transformUpdateTargetList(), transformWhereClause(), and transformWithClause().

Referenced by transformStmt().

transformUpdateTargetList()

List * transformUpdateTargetList	(	ParseState *	pstate,
		List *	origTlist
	)

Definition at line 2610 of file analyze.c.

{
    List       *tlist = NIL;
    RTEPermissionInfo *target_perminfo;
    ListCell   *orig_tl;
    ListCell   *tl;
 
    tlist = transformTargetList(pstate, origTlist,
                                EXPR_KIND_UPDATE_SOURCE);
 
    /* Prepare to assign non-conflicting resnos to resjunk attributes */
    if (pstate->p_next_resno <= RelationGetNumberOfAttributes(pstate->p_target_relation))
        pstate->p_next_resno = RelationGetNumberOfAttributes(pstate->p_target_relation) + 1;
 
    /* Prepare non-junk columns for assignment to target table */
    target_perminfo = pstate->p_target_nsitem->p_perminfo;
    orig_tl = list_head(origTlist);
 
    foreach(tl, tlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(tl);
        ResTarget  *origTarget;
        int         attrno;
 
        if (tle->resjunk)
        {
            /*
             * Resjunk nodes need no additional processing, but be sure they
             * have resnos that do not match any target columns; else rewriter
             * or planner might get confused.  They don't need a resname
             * either.
             */
            tle->resno = (AttrNumber) pstate->p_next_resno++;
            tle->resname = NULL;
            continue;
        }
        if (orig_tl == NULL)
            elog(ERROR, "UPDATE target count mismatch --- internal error");
        origTarget = lfirst_node(ResTarget, orig_tl);
 
        attrno = attnameAttNum(pstate->p_target_relation,
                               origTarget->name, true);
        if (attrno == InvalidAttrNumber)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_COLUMN),
                     errmsg("column \"%s\" of relation \"%s\" does not exist",
                            origTarget->name,
                            RelationGetRelationName(pstate->p_target_relation)),
                     (origTarget->indirection != NIL &&
                      strcmp(origTarget->name, pstate->p_target_nsitem->p_names->aliasname) == 0) ?
                     errhint("SET target columns cannot be qualified with the relation name.") : 0,
                     parser_errposition(pstate, origTarget->location)));
 
        updateTargetListEntry(pstate, tle, origTarget->name,
                              attrno,
                              origTarget->indirection,
                              origTarget->location);
 
        /* Mark the target column as requiring update permissions */
        target_perminfo->updatedCols = bms_add_member(target_perminfo->updatedCols,
                                                      attrno - FirstLowInvalidHeapAttributeNumber);
 
        orig_tl = lnext(origTlist, orig_tl);
    }
    if (orig_tl != NULL)
        elog(ERROR, "UPDATE target count mismatch --- internal error");
 
    return tlist;
}

References Alias::aliasname, attnameAttNum(), bms_add_member(), elog, ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_UPDATE_SOURCE, FirstLowInvalidHeapAttributeNumber, ResTarget::indirection, InvalidAttrNumber, lfirst, lfirst_node, list_head(), lnext(), ResTarget::location, ResTarget::name, NIL, ParseNamespaceItem::p_names, ParseState::p_next_resno, ParseNamespaceItem::p_perminfo, ParseState::p_target_nsitem, ParseState::p_target_relation, parser_errposition(), RelationGetNumberOfAttributes, RelationGetRelationName, TargetEntry::resno, transformTargetList(), RTEPermissionInfo::updatedCols, and updateTargetListEntry().

Referenced by transformMergeStmt(), transformOnConflictClause(), and transformUpdateStmt().

transformValuesClause()

static Query * transformValuesClause ( ParseState *  pstate, SelectStmt *  stmt  )

static

Definition at line 1604 of file analyze.c.

{
    Query      *qry = makeNode(Query);
    List       *exprsLists = NIL;
    List       *coltypes = NIL;
    List       *coltypmods = NIL;
    List       *colcollations = NIL;
    List      **colexprs = NULL;
    int         sublist_length = -1;
    bool        lateral = false;
    ParseNamespaceItem *nsitem;
    ListCell   *lc;
    ListCell   *lc2;
    int         i;
 
    qry->commandType = CMD_SELECT;
 
    /* Most SELECT stuff doesn't apply in a VALUES clause */
    Assert(stmt->distinctClause == NIL);
    Assert(stmt->intoClause == NULL);
    Assert(stmt->targetList == NIL);
    Assert(stmt->fromClause == NIL);
    Assert(stmt->whereClause == NULL);
    Assert(stmt->groupClause == NIL);
    Assert(stmt->havingClause == NULL);
    Assert(stmt->windowClause == NIL);
    Assert(stmt->op == SETOP_NONE);
 
    /* process the WITH clause independently of all else */
    if (stmt->withClause)
    {
        qry->hasRecursive = stmt->withClause->recursive;
        qry->cteList = transformWithClause(pstate, stmt->withClause);
        qry->hasModifyingCTE = pstate->p_hasModifyingCTE;
    }
 
    /*
     * For each row of VALUES, transform the raw expressions.
     *
     * Note that the intermediate representation we build is column-organized
     * not row-organized.  That simplifies the type and collation processing
     * below.
     */
    foreach(lc, stmt->valuesLists)
    {
        List       *sublist = (List *) lfirst(lc);
 
        /*
         * Do basic expression transformation (same as a ROW() expr, but here
         * we disallow SetToDefault)
         */
        sublist = transformExpressionList(pstate, sublist,
                                          EXPR_KIND_VALUES, false);
 
        /*
         * All the sublists must be the same length, *after* transformation
         * (which might expand '*' into multiple items).  The VALUES RTE can't
         * handle anything different.
         */
        if (sublist_length < 0)
        {
            /* Remember post-transformation length of first sublist */
            sublist_length = list_length(sublist);
            /* and allocate array for per-column lists */
            colexprs = (List **) palloc0(sublist_length * sizeof(List *));
        }
        else if (sublist_length != list_length(sublist))
        {
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("VALUES lists must all be the same length"),
                     parser_errposition(pstate,
                                        exprLocation((Node *) sublist))));
        }
 
        /* Build per-column expression lists */
        i = 0;
        foreach(lc2, sublist)
        {
            Node       *col = (Node *) lfirst(lc2);
 
            colexprs[i] = lappend(colexprs[i], col);
            i++;
        }
 
        /* Release sub-list's cells to save memory */
        list_free(sublist);
 
        /* Prepare an exprsLists element for this row */
        exprsLists = lappend(exprsLists, NIL);
    }
 
    /*
     * Now resolve the common types of the columns, and coerce everything to
     * those types.  Then identify the common typmod and common collation, if
     * any, of each column.
     *
     * We must do collation processing now because (1) assign_query_collations
     * doesn't process rangetable entries, and (2) we need to label the VALUES
     * RTE with column collations for use in the outer query.  We don't
     * consider conflict of implicit collations to be an error here; instead
     * the column will just show InvalidOid as its collation, and you'll get a
     * failure later if that results in failure to resolve a collation.
     *
     * Note we modify the per-column expression lists in-place.
     */
    for (i = 0; i < sublist_length; i++)
    {
        Oid         coltype;
        int32       coltypmod;
        Oid         colcoll;
 
        coltype = select_common_type(pstate, colexprs[i], "VALUES", NULL);
 
        foreach(lc, colexprs[i])
        {
            Node       *col = (Node *) lfirst(lc);
 
            col = coerce_to_common_type(pstate, col, coltype, "VALUES");
            lfirst(lc) = col;
        }
 
        coltypmod = select_common_typmod(pstate, colexprs[i], coltype);
        colcoll = select_common_collation(pstate, colexprs[i], true);
 
        coltypes = lappend_oid(coltypes, coltype);
        coltypmods = lappend_int(coltypmods, coltypmod);
        colcollations = lappend_oid(colcollations, colcoll);
    }
 
    /*
     * Finally, rearrange the coerced expressions into row-organized lists.
     */
    for (i = 0; i < sublist_length; i++)
    {
        forboth(lc, colexprs[i], lc2, exprsLists)
        {
            Node       *col = (Node *) lfirst(lc);
            List       *sublist = lfirst(lc2);
 
            sublist = lappend(sublist, col);
            lfirst(lc2) = sublist;
        }
        list_free(colexprs[i]);
    }
 
    /*
     * Ordinarily there can't be any current-level Vars in the expression
     * lists, because the namespace was empty ... but if we're inside CREATE
     * RULE, then NEW/OLD references might appear.  In that case we have to
     * mark the VALUES RTE as LATERAL.
     */
    if (pstate->p_rtable != NIL &&
        contain_vars_of_level((Node *) exprsLists, 0))
        lateral = true;
 
    /*
     * Generate the VALUES RTE
     */
    nsitem = addRangeTableEntryForValues(pstate, exprsLists,
                                         coltypes, coltypmods, colcollations,
                                         NULL, lateral, true);
    addNSItemToQuery(pstate, nsitem, true, true, true);
 
    /*
     * Generate a targetlist as though expanding "*"
     */
    Assert(pstate->p_next_resno == 1);
    qry->targetList = expandNSItemAttrs(pstate, nsitem, 0, true, -1);
 
    /*
     * The grammar allows attaching ORDER BY, LIMIT, and FOR UPDATE to a
     * VALUES, so cope.
     */
    qry->sortClause = transformSortClause(pstate,
                                          stmt->sortClause,
                                          &qry->targetList,
                                          EXPR_KIND_ORDER_BY,
                                          false /* allow SQL92 rules */ );
 
    qry->limitOffset = transformLimitClause(pstate, stmt->limitOffset,
                                            EXPR_KIND_OFFSET, "OFFSET",
                                            stmt->limitOption);
    qry->limitCount = transformLimitClause(pstate, stmt->limitCount,
                                           EXPR_KIND_LIMIT, "LIMIT",
                                           stmt->limitOption);
    qry->limitOption = stmt->limitOption;
 
    if (stmt->lockingClause)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
        /*------
          translator: %s is a SQL row locking clause such as FOR UPDATE */
                 errmsg("%s cannot be applied to VALUES",
                        LCS_asString(((LockingClause *)
                                      linitial(stmt->lockingClause))->strength))));
 
    qry->rtable = pstate->p_rtable;
    qry->rteperminfos = pstate->p_rteperminfos;
    qry->jointree = makeFromExpr(pstate->p_joinlist, NULL);
 
    qry->hasSubLinks = pstate->p_hasSubLinks;
 
    assign_query_collations(pstate, qry);
 
    return qry;
}

References addNSItemToQuery(), addRangeTableEntryForValues(), Assert(), assign_query_collations(), CMD_SELECT, coerce_to_common_type(), Query::commandType, contain_vars_of_level(), Query::cteList, ereport, errcode(), errmsg(), ERROR, expandNSItemAttrs(), EXPR_KIND_LIMIT, EXPR_KIND_OFFSET, EXPR_KIND_ORDER_BY, EXPR_KIND_VALUES, exprLocation(), forboth, i, Query::jointree, lappend(), lappend_int(), lappend_oid(), LCS_asString(), lfirst, Query::limitCount, Query::limitOffset, Query::limitOption, linitial, list_free(), list_length(), makeFromExpr(), makeNode, NIL, ParseState::p_hasModifyingCTE, ParseState::p_hasSubLinks, ParseState::p_joinlist, ParseState::p_next_resno, ParseState::p_rtable, ParseState::p_rteperminfos, palloc0(), parser_errposition(), Query::rtable, select_common_collation(), select_common_type(), select_common_typmod(), SETOP_NONE, Query::sortClause, stmt, Query::targetList, transformExpressionList(), transformLimitClause(), transformSortClause(), and transformWithClause().

Referenced by transformStmt().

Variable Documentation

post_parse_analyze_hook

post_parse_analyze_hook_type post_parse_analyze_hook = NULL

Definition at line 59 of file analyze.c.

Referenced by _PG_init(), ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), parse_analyze_fixedparams(), parse_analyze_varparams(), parse_analyze_withcb(), and PerformCursorOpen().