parse_target.c File Reference

#include "postgres.h"
#include "catalog/namespace.h"
#include "catalog/pg_type.h"
#include "commands/dbcommands.h"
#include "funcapi.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "parser/parsetree.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/rel.h"

Include dependency graph for parse_target.c:

Go to the source code of this file.

Functions
static void	markTargetListOrigin (ParseState *pstate, TargetEntry *tle, Var *var, int levelsup)
static Node *	transformAssignmentSubscripts (ParseState *pstate, Node *basenode, const char *targetName, Oid targetTypeId, int32 targetTypMod, Oid targetCollation, List *subscripts, List *indirection, ListCell *next_indirection, Node *rhs, CoercionContext ccontext, int location)
static List *	ExpandColumnRefStar (ParseState *pstate, ColumnRef *cref, bool make_target_entry)
static List *	ExpandAllTables (ParseState *pstate, int location)
static List *	ExpandIndirectionStar (ParseState *pstate, A_Indirection *ind, bool make_target_entry, ParseExprKind exprKind)
static List *	ExpandSingleTable (ParseState *pstate, ParseNamespaceItem *nsitem, int sublevels_up, int location, bool make_target_entry)
static List *	ExpandRowReference (ParseState *pstate, Node *expr, bool make_target_entry)
static int	FigureColnameInternal (Node *node, char **name)
TargetEntry *	transformTargetEntry (ParseState *pstate, Node *node, Node *expr, ParseExprKind exprKind, char *colname, bool resjunk)
List *	transformTargetList (ParseState *pstate, List *targetlist, ParseExprKind exprKind)
List *	transformExpressionList (ParseState *pstate, List *exprlist, ParseExprKind exprKind, bool allowDefault)
void	resolveTargetListUnknowns (ParseState *pstate, List *targetlist)
void	markTargetListOrigins (ParseState *pstate, List *targetlist)
Expr *	transformAssignedExpr (ParseState *pstate, Expr *expr, ParseExprKind exprKind, const char *colname, int attrno, List *indirection, int location)
void	updateTargetListEntry (ParseState *pstate, TargetEntry *tle, char *colname, int attrno, List *indirection, int location)
Node *	transformAssignmentIndirection (ParseState *pstate, Node *basenode, const char *targetName, bool targetIsSubscripting, Oid targetTypeId, int32 targetTypMod, Oid targetCollation, List *indirection, ListCell *indirection_cell, Node *rhs, CoercionContext ccontext, int location)
List *	checkInsertTargets (ParseState *pstate, List *cols, List **attrnos)
TupleDesc	expandRecordVariable (ParseState *pstate, Var *var, int levelsup)
char *	FigureColname (Node *node)
char *	FigureIndexColname (Node *node)

Function Documentation

checkInsertTargets()

List * checkInsertTargets	(	ParseState *	pstate,
		List *	cols,
		List **	attrnos
	)

Definition at line 1018 of file parse_target.c.

{
    *attrnos = NIL;
 
    if (cols == NIL)
    {
        /*
         * Generate default column list for INSERT.
         */
        int         numcol = RelationGetNumberOfAttributes(pstate->p_target_relation);
 
        int         i;
 
        for (i = 0; i < numcol; i++)
        {
            ResTarget  *col;
            Form_pg_attribute attr;
 
            attr = TupleDescAttr(pstate->p_target_relation->rd_att, i);
 
            if (attr->attisdropped)
                continue;
 
            col = makeNode(ResTarget);
            col->name = pstrdup(NameStr(attr->attname));
            col->indirection = NIL;
            col->val = NULL;
            col->location = -1;
            cols = lappend(cols, col);
            *attrnos = lappend_int(*attrnos, i + 1);
        }
    }
    else
    {
        /*
         * Do initial validation of user-supplied INSERT column list.
         */
        Bitmapset  *wholecols = NULL;
        Bitmapset  *partialcols = NULL;
        ListCell   *tl;
 
        foreach(tl, cols)
        {
            ResTarget  *col = (ResTarget *) lfirst(tl);
            char       *name = col->name;
            int         attrno;
 
            /* Lookup column name, ereport on failure */
            attrno = attnameAttNum(pstate->p_target_relation, name, false);
            if (attrno == InvalidAttrNumber)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("column \"%s\" of relation \"%s\" does not exist",
                                name,
                                RelationGetRelationName(pstate->p_target_relation)),
                         parser_errposition(pstate, col->location)));
 
            /*
             * Check for duplicates, but only of whole columns --- we allow
             * INSERT INTO foo (col.subcol1, col.subcol2)
             */
            if (col->indirection == NIL)
            {
                /* whole column; must not have any other assignment */
                if (bms_is_member(attrno, wholecols) ||
                    bms_is_member(attrno, partialcols))
                    ereport(ERROR,
                            (errcode(ERRCODE_DUPLICATE_COLUMN),
                             errmsg("column \"%s\" specified more than once",
                                    name),
                             parser_errposition(pstate, col->location)));
                wholecols = bms_add_member(wholecols, attrno);
            }
            else
            {
                /* partial column; must not have any whole assignment */
                if (bms_is_member(attrno, wholecols))
                    ereport(ERROR,
                            (errcode(ERRCODE_DUPLICATE_COLUMN),
                             errmsg("column \"%s\" specified more than once",
                                    name),
                             parser_errposition(pstate, col->location)));
                partialcols = bms_add_member(partialcols, attrno);
            }
 
            *attrnos = lappend_int(*attrnos, attrno);
        }
    }
 
    return cols;
}

References attnameAttNum(), bms_add_member(), bms_is_member(), ereport, errcode(), errmsg(), ERROR, i, ResTarget::indirection, InvalidAttrNumber, lappend(), lappend_int(), lfirst, ResTarget::location, makeNode, name, ResTarget::name, NameStr, NIL, ParseState::p_target_relation, parser_errposition(), pstrdup(), RelationData::rd_att, RelationGetNumberOfAttributes, RelationGetRelationName, TupleDescAttr(), and ResTarget::val.

Referenced by transformInsertStmt(), and transformMergeStmt().

ExpandAllTables()

static List * ExpandAllTables ( ParseState *  pstate, int  location  )

static

Definition at line 1296 of file parse_target.c.

{
    List       *target = NIL;
    bool        found_table = false;
    ListCell   *l;
 
    foreach(l, pstate->p_namespace)
    {
        ParseNamespaceItem *nsitem = (ParseNamespaceItem *) lfirst(l);
 
        /* Ignore table-only items */
        if (!nsitem->p_cols_visible)
            continue;
        /* Should not have any lateral-only items when parsing targetlist */
        Assert(!nsitem->p_lateral_only);
        /* Remember we found a p_cols_visible item */
        found_table = true;
 
        target = list_concat(target,
                             expandNSItemAttrs(pstate,
                                               nsitem,
                                               0,
                                               true,
                                               location));
    }
 
    /*
     * Check for "SELECT *;".  We do it this way, rather than checking for
     * target == NIL, because we want to allow SELECT * FROM a zero_column
     * table.
     */
    if (!found_table)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("SELECT * with no tables specified is not valid"),
                 parser_errposition(pstate, location)));
 
    return target;
}

References Assert(), ereport, errcode(), errmsg(), ERROR, expandNSItemAttrs(), lfirst, list_concat(), NIL, ParseNamespaceItem::p_cols_visible, ParseNamespaceItem::p_lateral_only, ParseState::p_namespace, and parser_errposition().

Referenced by ExpandColumnRefStar().

ExpandColumnRefStar()

static List * ExpandColumnRefStar ( ParseState *  pstate, ColumnRef *  cref, bool  make_target_entry  )

static

Definition at line 1123 of file parse_target.c.

{
    List       *fields = cref->fields;
    int         numnames = list_length(fields);
 
    if (numnames == 1)
    {
        /*
         * Target item is a bare '*', expand all tables
         *
         * (e.g., SELECT * FROM emp, dept)
         *
         * Since the grammar only accepts bare '*' at top level of SELECT, we
         * need not handle the make_target_entry==false case here.
         */
        Assert(make_target_entry);
        return ExpandAllTables(pstate, cref->location);
    }
    else
    {
        /*
         * Target item is relation.*, expand that table
         *
         * (e.g., SELECT emp.*, dname FROM emp, dept)
         *
         * Note: this code is a lot like transformColumnRef; it's tempting to
         * call that instead and then replace the resulting whole-row Var with
         * a list of Vars.  However, that would leave us with the relation's
         * selectedCols bitmap showing the whole row as needing select
         * permission, as well as the individual columns.  That would be
         * incorrect (since columns added later shouldn't need select
         * permissions).  We could try to remove the whole-row permission bit
         * after the fact, but duplicating code is less messy.
         */
        char       *nspname = NULL;
        char       *relname = NULL;
        ParseNamespaceItem *nsitem = NULL;
        int         levels_up;
        enum
        {
            CRSERR_NO_RTE,
            CRSERR_WRONG_DB,
            CRSERR_TOO_MANY
        }           crserr = CRSERR_NO_RTE;
 
        /*
         * Give the PreParseColumnRefHook, if any, first shot.  If it returns
         * non-null then we should use that expression.
         */
        if (pstate->p_pre_columnref_hook != NULL)
        {
            Node       *node;
 
            node = pstate->p_pre_columnref_hook(pstate, cref);
            if (node != NULL)
                return ExpandRowReference(pstate, node, make_target_entry);
        }
 
        switch (numnames)
        {
            case 2:
                relname = strVal(linitial(fields));
                nsitem = refnameNamespaceItem(pstate, nspname, relname,
                                              cref->location,
                                              &levels_up);
                break;
            case 3:
                nspname = strVal(linitial(fields));
                relname = strVal(lsecond(fields));
                nsitem = refnameNamespaceItem(pstate, nspname, relname,
                                              cref->location,
                                              &levels_up);
                break;
            case 4:
                {
                    char       *catname = strVal(linitial(fields));
 
                    /*
                     * We check the catalog name and then ignore it.
                     */
                    if (strcmp(catname, get_database_name(MyDatabaseId)) != 0)
                    {
                        crserr = CRSERR_WRONG_DB;
                        break;
                    }
                    nspname = strVal(lsecond(fields));
                    relname = strVal(lthird(fields));
                    nsitem = refnameNamespaceItem(pstate, nspname, relname,
                                                  cref->location,
                                                  &levels_up);
                    break;
                }
            default:
                crserr = CRSERR_TOO_MANY;
                break;
        }
 
        /*
         * Now give the PostParseColumnRefHook, if any, a chance. We cheat a
         * bit by passing the RangeTblEntry, not a Var, as the planned
         * translation.  (A single Var wouldn't be strictly correct anyway.
         * This convention allows hooks that really care to know what is
         * happening.  It might be better to pass the nsitem, but we'd have to
         * promote that struct to a full-fledged Node type so that callees
         * could identify its type.)
         */
        if (pstate->p_post_columnref_hook != NULL)
        {
            Node       *node;
 
            node = pstate->p_post_columnref_hook(pstate, cref,
                                                 (Node *) (nsitem ? nsitem->p_rte : NULL));
            if (node != NULL)
            {
                if (nsitem != NULL)
                    ereport(ERROR,
                            (errcode(ERRCODE_AMBIGUOUS_COLUMN),
                             errmsg("column reference \"%s\" is ambiguous",
                                    NameListToString(cref->fields)),
                             parser_errposition(pstate, cref->location)));
                return ExpandRowReference(pstate, node, make_target_entry);
            }
        }
 
        /*
         * Throw error if no translation found.
         */
        if (nsitem == NULL)
        {
            switch (crserr)
            {
                case CRSERR_NO_RTE:
                    errorMissingRTE(pstate, makeRangeVar(nspname, relname,
                                                         cref->location));
                    break;
                case CRSERR_WRONG_DB:
                    ereport(ERROR,
                            (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                             errmsg("cross-database references are not implemented: %s",
                                    NameListToString(cref->fields)),
                             parser_errposition(pstate, cref->location)));
                    break;
                case CRSERR_TOO_MANY:
                    ereport(ERROR,
                            (errcode(ERRCODE_SYNTAX_ERROR),
                             errmsg("improper qualified name (too many dotted names): %s",
                                    NameListToString(cref->fields)),
                             parser_errposition(pstate, cref->location)));
                    break;
            }
        }
 
        /*
         * OK, expand the nsitem into fields.
         */
        return ExpandSingleTable(pstate, nsitem, levels_up, cref->location,
                                 make_target_entry);
    }
}

References Assert(), ereport, errcode(), errmsg(), ERROR, errorMissingRTE(), ExpandAllTables(), ExpandRowReference(), ExpandSingleTable(), ColumnRef::fields, get_database_name(), linitial, list_length(), ColumnRef::location, lsecond, lthird, makeRangeVar(), MyDatabaseId, NameListToString(), ParseState::p_post_columnref_hook, ParseState::p_pre_columnref_hook, ParseNamespaceItem::p_rte, parser_errposition(), refnameNamespaceItem(), relname, and strVal.

Referenced by transformExpressionList(), and transformTargetList().

ExpandIndirectionStar()

static List * ExpandIndirectionStar ( ParseState *  pstate, A_Indirection *  ind, bool  make_target_entry, ParseExprKind  exprKind  )

static

Definition at line 1348 of file parse_target.c.

{
    Node       *expr;
 
    /* Strip off the '*' to create a reference to the rowtype object */
    ind = copyObject(ind);
    ind->indirection = list_truncate(ind->indirection,
                                     list_length(ind->indirection) - 1);
 
    /* And transform that */
    expr = transformExpr(pstate, (Node *) ind, exprKind);
 
    /* Expand the rowtype expression into individual fields */
    return ExpandRowReference(pstate, expr, make_target_entry);
}

References copyObject, ExpandRowReference(), list_length(), list_truncate(), and transformExpr().

Referenced by transformExpressionList(), and transformTargetList().

expandRecordVariable()

TupleDesc expandRecordVariable	(	ParseState *	pstate,
		Var *	var,
		int	levelsup
	)

Definition at line 1522 of file parse_target.c.

{
    TupleDesc   tupleDesc;
    int         netlevelsup;
    RangeTblEntry *rte;
    AttrNumber  attnum;
    Node       *expr;
 
    /* Check my caller didn't mess up */
    Assert(IsA(var, Var));
    Assert(var->vartype == RECORDOID);
 
    /*
     * Note: it's tempting to use GetNSItemByRangeTablePosn here so that we
     * can use expandNSItemVars instead of expandRTE; but that does not work
     * for some of the recursion cases below, where we have consed up a
     * ParseState that lacks p_namespace data.
     */
    netlevelsup = var->varlevelsup + levelsup;
    rte = GetRTEByRangeTablePosn(pstate, var->varno, netlevelsup);
    attnum = var->varattno;
 
    if (attnum == InvalidAttrNumber)
    {
        /* Whole-row reference to an RTE, so expand the known fields */
        List       *names,
                   *vars;
        ListCell   *lname,
                   *lvar;
        int         i;
 
        expandRTE(rte, var->varno, 0, var->varreturningtype,
                  var->location, false, &names, &vars);
 
        tupleDesc = CreateTemplateTupleDesc(list_length(vars));
        i = 1;
        forboth(lname, names, lvar, vars)
        {
            char       *label = strVal(lfirst(lname));
            Node       *varnode = (Node *) lfirst(lvar);
 
            TupleDescInitEntry(tupleDesc, i,
                               label,
                               exprType(varnode),
                               exprTypmod(varnode),
                               0);
            TupleDescInitEntryCollation(tupleDesc, i,
                                        exprCollation(varnode));
            i++;
        }
        Assert(lname == NULL && lvar == NULL);  /* lists same length? */
 
        return tupleDesc;
    }
 
    expr = (Node *) var;        /* default if we can't drill down */
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
        case RTE_VALUES:
        case RTE_NAMEDTUPLESTORE:
        case RTE_RESULT:
 
            /*
             * This case should not occur: a column of a table, values list,
             * or ENR shouldn't have type RECORD.  Fall through and fail (most
             * likely) at the bottom.
             */
            break;
        case 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)
                    elog(ERROR, "subquery %s does not have attribute %d",
                         rte->eref->aliasname, attnum);
                expr = (Node *) ste->expr;
                if (IsA(expr, Var))
                {
                    /*
                     * Recurse into the sub-select to see what its Var refers
                     * to.  We have to build an additional level of ParseState
                     * to keep in step with varlevelsup in the subselect;
                     * furthermore, the subquery RTE might be from an outer
                     * query level, in which case the ParseState for the
                     * subselect must have that outer level as parent.
                     */
                    ParseState  mypstate = {0};
                    Index       levelsup;
 
                    /* this loop must work, since GetRTEByRangeTablePosn did */
                    for (levelsup = 0; levelsup < netlevelsup; levelsup++)
                        pstate = pstate->parentParseState;
                    mypstate.parentParseState = pstate;
                    mypstate.p_rtable = rte->subquery->rtable;
                    /* don't bother filling the rest of the fake pstate */
 
                    return expandRecordVariable(&mypstate, (Var *) expr, 0);
                }
                /* else fall through to inspect the expression */
            }
            break;
        case RTE_JOIN:
            /* Join RTE --- recursively inspect the alias variable */
            Assert(attnum > 0 && attnum <= list_length(rte->joinaliasvars));
            expr = (Node *) list_nth(rte->joinaliasvars, attnum - 1);
            Assert(expr != NULL);
            /* We intentionally don't strip implicit coercions here */
            if (IsA(expr, Var))
                return expandRecordVariable(pstate, (Var *) expr, netlevelsup);
            /* else fall through to inspect the expression */
            break;
        case RTE_FUNCTION:
 
            /*
             * We couldn't get here unless a function is declared with one of
             * its result columns as RECORD, which is not allowed.
             */
            break;
        case RTE_TABLEFUNC:
 
            /*
             * Table function cannot have columns with RECORD type.
             */
            break;
        case RTE_CTE:
            /* CTE reference: examine subquery's output expr */
            if (!rte->self_reference)
            {
                CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
                TargetEntry *ste;
 
                ste = get_tle_by_resno(GetCTETargetList(cte), attnum);
                if (ste == NULL || ste->resjunk)
                    elog(ERROR, "CTE %s does not have attribute %d",
                         rte->eref->aliasname, attnum);
                expr = (Node *) ste->expr;
                if (IsA(expr, Var))
                {
                    /*
                     * Recurse into the CTE to see what its Var refers to. We
                     * have to build an additional level of ParseState to keep
                     * in step with varlevelsup in the CTE; furthermore it
                     * could be an outer CTE (compare SUBQUERY case above).
                     */
                    ParseState  mypstate = {0};
                    Index       levelsup;
 
                    /* this loop must work, since GetCTEForRTE did */
                    for (levelsup = 0;
                         levelsup < rte->ctelevelsup + netlevelsup;
                         levelsup++)
                        pstate = pstate->parentParseState;
                    mypstate.parentParseState = pstate;
                    mypstate.p_rtable = ((Query *) cte->ctequery)->rtable;
                    /* don't bother filling the rest of the fake pstate */
 
                    return expandRecordVariable(&mypstate, (Var *) expr, 0);
                }
                /* else fall through to inspect the expression */
            }
            break;
        case RTE_GROUP:
 
            /*
             * We couldn't get here: the RTE_GROUP RTE has not been added.
             */
            break;
    }
 
    /*
     * We now have an expression we can't expand any more, so see if
     * get_expr_result_tupdesc() can do anything with it.
     */
    return get_expr_result_tupdesc(expr, false);
}

References Assert(), attnum, CreateTemplateTupleDesc(), RangeTblEntry::ctelevelsup, CommonTableExpr::ctequery, elog, ERROR, expandRecordVariable(), expandRTE(), TargetEntry::expr, exprCollation(), exprType(), exprTypmod(), forboth, get_expr_result_tupdesc(), get_tle_by_resno(), GetCTEForRTE(), GetCTETargetList, GetRTEByRangeTablePosn(), i, if(), InvalidAttrNumber, IsA, label, lfirst, list_length(), list_nth(), Var::location, ParseState::p_rtable, ParseState::parentParseState, Query::rtable, RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, strVal, RangeTblEntry::subquery, Query::targetList, TupleDescInitEntry(), TupleDescInitEntryCollation(), Var::varattno, Var::varlevelsup, Var::varno, and Var::varreturningtype.

Referenced by expandRecordVariable(), ExpandRowReference(), and ParseComplexProjection().

ExpandRowReference()

static List * ExpandRowReference ( ParseState *  pstate, Node *  expr, bool  make_target_entry  )

static

Definition at line 1426 of file parse_target.c.

{
    List       *result = NIL;
    TupleDesc   tupleDesc;
    int         numAttrs;
    int         i;
 
    /*
     * If the rowtype expression is a whole-row Var, we can expand the fields
     * as simple Vars.  Note: if the RTE is a relation, this case leaves us
     * with its RTEPermissionInfo's selectedCols bitmap showing the whole row
     * as needing select permission, as well as the individual columns.
     * However, we can only get here for weird notations like (table.*).*, so
     * it's not worth trying to clean up --- arguably, the permissions marking
     * is correct anyway for such cases.
     */
    if (IsA(expr, Var) &&
        ((Var *) expr)->varattno == InvalidAttrNumber)
    {
        Var        *var = (Var *) expr;
        ParseNamespaceItem *nsitem;
 
        nsitem = GetNSItemByRangeTablePosn(pstate, var->varno, var->varlevelsup);
        return ExpandSingleTable(pstate, nsitem, var->varlevelsup, var->location, make_target_entry);
    }
 
    /*
     * Otherwise we have to do it the hard way.  Our current implementation is
     * to generate multiple copies of the expression and do FieldSelects.
     * (This can be pretty inefficient if the expression involves nontrivial
     * computation :-(.)
     *
     * Verify it's a composite type, and get the tupdesc.
     * get_expr_result_tupdesc() handles this conveniently.
     *
     * If it's a Var of type RECORD, we have to work even harder: we have to
     * find what the Var refers to, and pass that to get_expr_result_tupdesc.
     * That task is handled by expandRecordVariable().
     */
    if (IsA(expr, Var) &&
        ((Var *) expr)->vartype == RECORDOID)
        tupleDesc = expandRecordVariable(pstate, (Var *) expr, 0);
    else
        tupleDesc = get_expr_result_tupdesc(expr, false);
    Assert(tupleDesc);
 
    /* Generate a list of references to the individual fields */
    numAttrs = tupleDesc->natts;
    for (i = 0; i < numAttrs; i++)
    {
        Form_pg_attribute att = TupleDescAttr(tupleDesc, i);
        FieldSelect *fselect;
 
        if (att->attisdropped)
            continue;
 
        fselect = makeNode(FieldSelect);
        fselect->arg = (Expr *) copyObject(expr);
        fselect->fieldnum = i + 1;
        fselect->resulttype = att->atttypid;
        fselect->resulttypmod = att->atttypmod;
        /* save attribute's collation for parse_collate.c */
        fselect->resultcollid = att->attcollation;
 
        if (make_target_entry)
        {
            /* add TargetEntry decoration */
            TargetEntry *te;
 
            te = makeTargetEntry((Expr *) fselect,
                                 (AttrNumber) pstate->p_next_resno++,
                                 pstrdup(NameStr(att->attname)),
                                 false);
            result = lappend(result, te);
        }
        else
            result = lappend(result, fselect);
    }
 
    return result;
}

References FieldSelect::arg, Assert(), copyObject, expandRecordVariable(), ExpandSingleTable(), FieldSelect::fieldnum, get_expr_result_tupdesc(), GetNSItemByRangeTablePosn(), i, InvalidAttrNumber, IsA, lappend(), Var::location, makeNode, makeTargetEntry(), NameStr, TupleDescData::natts, NIL, ParseState::p_next_resno, pstrdup(), TupleDescAttr(), Var::varlevelsup, and Var::varno.

Referenced by ExpandColumnRefStar(), and ExpandIndirectionStar().

ExpandSingleTable()

static List * ExpandSingleTable ( ParseState *  pstate, ParseNamespaceItem *  nsitem, int  sublevels_up, int  location, bool  make_target_entry  )

static

Definition at line 1375 of file parse_target.c.

{
    if (make_target_entry)
    {
        /* expandNSItemAttrs handles permissions marking */
        return expandNSItemAttrs(pstate, nsitem, sublevels_up, true, location);
    }
    else
    {
        RangeTblEntry *rte = nsitem->p_rte;
        RTEPermissionInfo *perminfo = nsitem->p_perminfo;
        List       *vars;
        ListCell   *l;
 
        vars = expandNSItemVars(pstate, nsitem, sublevels_up, location, NULL);
 
        /*
         * Require read access to the table.  This is normally redundant with
         * the markVarForSelectPriv calls below, but not if the table has zero
         * columns.  We need not do anything if the nsitem is for a join: its
         * component tables will have been marked ACL_SELECT when they were
         * added to the rangetable.  (This step changes things only for the
         * target relation of UPDATE/DELETE, which cannot be under a join.)
         */
        if (rte->rtekind == RTE_RELATION)
        {
            Assert(perminfo != NULL);
            perminfo->requiredPerms |= ACL_SELECT;
        }
 
        /* Require read access to each column */
        foreach(l, vars)
        {
            Var        *var = (Var *) lfirst(l);
 
            markVarForSelectPriv(pstate, var);
        }
 
        return vars;
    }
}

References ACL_SELECT, Assert(), expandNSItemAttrs(), expandNSItemVars(), lfirst, markVarForSelectPriv(), ParseNamespaceItem::p_perminfo, ParseNamespaceItem::p_rte, RTEPermissionInfo::requiredPerms, RTE_RELATION, and RangeTblEntry::rtekind.

Referenced by ExpandColumnRefStar(), and ExpandRowReference().

FigureColname()

char * FigureColname

(

Node *

node

)

Definition at line 1713 of file parse_target.c.

{
    char       *name = NULL;
 
    (void) FigureColnameInternal(node, &name);
    if (name != NULL)
        return name;
    /* default result if we can't guess anything */
    return "?column?";
}

References FigureColnameInternal(), and name.

Referenced by transformRangeFunction(), transformTargetEntry(), and transformXmlExpr().

FigureColnameInternal()

static int FigureColnameInternal ( Node *  node, char **  name  )

static

Definition at line 1752 of file parse_target.c.

{
    int         strength = 0;
 
    if (node == NULL)
        return strength;
 
    switch (nodeTag(node))
    {
        case T_ColumnRef:
            {
                char       *fname = NULL;
                ListCell   *l;
 
                /* find last field name, if any, ignoring "*" */
                foreach(l, ((ColumnRef *) node)->fields)
                {
                    Node       *i = lfirst(l);
 
                    if (IsA(i, String))
                        fname = strVal(i);
                }
                if (fname)
                {
                    *name = fname;
                    return 2;
                }
            }
            break;
        case T_A_Indirection:
            {
                A_Indirection *ind = (A_Indirection *) node;
                char       *fname = NULL;
                ListCell   *l;
 
                /* find last field name, if any, ignoring "*" and subscripts */
                foreach(l, ind->indirection)
                {
                    Node       *i = lfirst(l);
 
                    if (IsA(i, String))
                        fname = strVal(i);
                }
                if (fname)
                {
                    *name = fname;
                    return 2;
                }
                return FigureColnameInternal(ind->arg, name);
            }
            break;
        case T_FuncCall:
            *name = strVal(llast(((FuncCall *) node)->funcname));
            return 2;
        case T_A_Expr:
            if (((A_Expr *) node)->kind == AEXPR_NULLIF)
            {
                /* make nullif() act like a regular function */
                *name = "nullif";
                return 2;
            }
            break;
        case T_TypeCast:
            strength = FigureColnameInternal(((TypeCast *) node)->arg,
                                             name);
            if (strength <= 1)
            {
                if (((TypeCast *) node)->typeName != NULL)
                {
                    *name = strVal(llast(((TypeCast *) node)->typeName->names));
                    return 1;
                }
            }
            break;
        case T_CollateClause:
            return FigureColnameInternal(((CollateClause *) node)->arg, name);
        case T_GroupingFunc:
            /* make GROUPING() act like a regular function */
            *name = "grouping";
            return 2;
        case T_MergeSupportFunc:
            /* make MERGE_ACTION() act like a regular function */
            *name = "merge_action";
            return 2;
        case T_SubLink:
            switch (((SubLink *) node)->subLinkType)
            {
                case EXISTS_SUBLINK:
                    *name = "exists";
                    return 2;
                case ARRAY_SUBLINK:
                    *name = "array";
                    return 2;
                case EXPR_SUBLINK:
                    {
                        /* Get column name of the subquery's single target */
                        SubLink    *sublink = (SubLink *) node;
                        Query      *query = (Query *) sublink->subselect;
 
                        /*
                         * The subquery has probably already been transformed,
                         * but let's be careful and check that.  (The reason
                         * we can see a transformed subquery here is that
                         * transformSubLink is lazy and modifies the SubLink
                         * node in-place.)
                         */
                        if (IsA(query, Query))
                        {
                            TargetEntry *te = (TargetEntry *) linitial(query->targetList);
 
                            if (te->resname)
                            {
                                *name = te->resname;
                                return 2;
                            }
                        }
                    }
                    break;
                    /* As with other operator-like nodes, these have no names */
                case MULTIEXPR_SUBLINK:
                case ALL_SUBLINK:
                case ANY_SUBLINK:
                case ROWCOMPARE_SUBLINK:
                case CTE_SUBLINK:
                    break;
            }
            break;
        case T_CaseExpr:
            strength = FigureColnameInternal((Node *) ((CaseExpr *) node)->defresult,
                                             name);
            if (strength <= 1)
            {
                *name = "case";
                return 1;
            }
            break;
        case T_A_ArrayExpr:
            /* make ARRAY[] act like a function */
            *name = "array";
            return 2;
        case T_RowExpr:
            /* make ROW() act like a function */
            *name = "row";
            return 2;
        case T_CoalesceExpr:
            /* make coalesce() act like a regular function */
            *name = "coalesce";
            return 2;
        case T_MinMaxExpr:
            /* make greatest/least act like a regular function */
            switch (((MinMaxExpr *) node)->op)
            {
                case IS_GREATEST:
                    *name = "greatest";
                    return 2;
                case IS_LEAST:
                    *name = "least";
                    return 2;
            }
            break;
        case T_SQLValueFunction:
            /* make these act like a function or variable */
            switch (((SQLValueFunction *) node)->op)
            {
                case SVFOP_CURRENT_DATE:
                    *name = "current_date";
                    return 2;
                case SVFOP_CURRENT_TIME:
                case SVFOP_CURRENT_TIME_N:
                    *name = "current_time";
                    return 2;
                case SVFOP_CURRENT_TIMESTAMP:
                case SVFOP_CURRENT_TIMESTAMP_N:
                    *name = "current_timestamp";
                    return 2;
                case SVFOP_LOCALTIME:
                case SVFOP_LOCALTIME_N:
                    *name = "localtime";
                    return 2;
                case SVFOP_LOCALTIMESTAMP:
                case SVFOP_LOCALTIMESTAMP_N:
                    *name = "localtimestamp";
                    return 2;
                case SVFOP_CURRENT_ROLE:
                    *name = "current_role";
                    return 2;
                case SVFOP_CURRENT_USER:
                    *name = "current_user";
                    return 2;
                case SVFOP_USER:
                    *name = "user";
                    return 2;
                case SVFOP_SESSION_USER:
                    *name = "session_user";
                    return 2;
                case SVFOP_CURRENT_CATALOG:
                    *name = "current_catalog";
                    return 2;
                case SVFOP_CURRENT_SCHEMA:
                    *name = "current_schema";
                    return 2;
            }
            break;
        case T_XmlExpr:
            /* make SQL/XML functions act like a regular function */
            switch (((XmlExpr *) node)->op)
            {
                case IS_XMLCONCAT:
                    *name = "xmlconcat";
                    return 2;
                case IS_XMLELEMENT:
                    *name = "xmlelement";
                    return 2;
                case IS_XMLFOREST:
                    *name = "xmlforest";
                    return 2;
                case IS_XMLPARSE:
                    *name = "xmlparse";
                    return 2;
                case IS_XMLPI:
                    *name = "xmlpi";
                    return 2;
                case IS_XMLROOT:
                    *name = "xmlroot";
                    return 2;
                case IS_XMLSERIALIZE:
                    *name = "xmlserialize";
                    return 2;
                case IS_DOCUMENT:
                    /* nothing */
                    break;
            }
            break;
        case T_XmlSerialize:
            /* make XMLSERIALIZE act like a regular function */
            *name = "xmlserialize";
            return 2;
        case T_JsonParseExpr:
            /* make JSON act like a regular function */
            *name = "json";
            return 2;
        case T_JsonScalarExpr:
            /* make JSON_SCALAR act like a regular function */
            *name = "json_scalar";
            return 2;
        case T_JsonSerializeExpr:
            /* make JSON_SERIALIZE act like a regular function */
            *name = "json_serialize";
            return 2;
        case T_JsonObjectConstructor:
            /* make JSON_OBJECT act like a regular function */
            *name = "json_object";
            return 2;
        case T_JsonArrayConstructor:
        case T_JsonArrayQueryConstructor:
            /* make JSON_ARRAY act like a regular function */
            *name = "json_array";
            return 2;
        case T_JsonObjectAgg:
            /* make JSON_OBJECTAGG act like a regular function */
            *name = "json_objectagg";
            return 2;
        case T_JsonArrayAgg:
            /* make JSON_ARRAYAGG act like a regular function */
            *name = "json_arrayagg";
            return 2;
        case T_JsonFuncExpr:
            /* make SQL/JSON functions act like a regular function */
            switch (((JsonFuncExpr *) node)->op)
            {
                case JSON_EXISTS_OP:
                    *name = "json_exists";
                    return 2;
                case JSON_QUERY_OP:
                    *name = "json_query";
                    return 2;
                case JSON_VALUE_OP:
                    *name = "json_value";
                    return 2;
                    /* JSON_TABLE_OP can't happen here. */
                default:
                    elog(ERROR, "unrecognized JsonExpr op: %d",
                         (int) ((JsonFuncExpr *) node)->op);
            }
            break;
        default:
            break;
    }
 
    return strength;
}

References AEXPR_NULLIF, ALL_SUBLINK, ANY_SUBLINK, arg, ARRAY_SUBLINK, CTE_SUBLINK, elog, ERROR, EXISTS_SUBLINK, EXPR_SUBLINK, FigureColnameInternal(), funcname, i, if(), IS_DOCUMENT, IS_GREATEST, IS_LEAST, IS_XMLCONCAT, IS_XMLELEMENT, IS_XMLFOREST, IS_XMLPARSE, IS_XMLPI, IS_XMLROOT, IS_XMLSERIALIZE, IsA, JSON_EXISTS_OP, JSON_QUERY_OP, JSON_VALUE_OP, lfirst, linitial, llast, MULTIEXPR_SUBLINK, name, nodeTag, ROWCOMPARE_SUBLINK, strVal, SubLink::subselect, SVFOP_CURRENT_CATALOG, SVFOP_CURRENT_DATE, SVFOP_CURRENT_ROLE, SVFOP_CURRENT_SCHEMA, SVFOP_CURRENT_TIME, SVFOP_CURRENT_TIME_N, SVFOP_CURRENT_TIMESTAMP, SVFOP_CURRENT_TIMESTAMP_N, SVFOP_CURRENT_USER, SVFOP_LOCALTIME, SVFOP_LOCALTIME_N, SVFOP_LOCALTIMESTAMP, SVFOP_LOCALTIMESTAMP_N, SVFOP_SESSION_USER, SVFOP_USER, and Query::targetList.

Referenced by FigureColname(), FigureColnameInternal(), and FigureIndexColname().

FigureIndexColname()

char * FigureIndexColname

(

Node *

node

)

Definition at line 1732 of file parse_target.c.

{
    char       *name = NULL;
 
    (void) FigureColnameInternal(node, &name);
    return name;
}

References FigureColnameInternal(), and name.

Referenced by transformIndexStmt().

markTargetListOrigin()

static void markTargetListOrigin ( ParseState *  pstate, TargetEntry *  tle, Var *  var, int  levelsup  )

static

Definition at line 343 of file parse_target.c.

{
    int         netlevelsup;
    RangeTblEntry *rte;
    AttrNumber  attnum;
 
    if (var == NULL || !IsA(var, Var))
        return;
    netlevelsup = var->varlevelsup + levelsup;
    rte = GetRTEByRangeTablePosn(pstate, var->varno, netlevelsup);
    attnum = var->varattno;
 
    switch (rte->rtekind)
    {
        case RTE_RELATION:
            /* It's a table or view, report it */
            tle->resorigtbl = rte->relid;
            tle->resorigcol = attnum;
            break;
        case RTE_SUBQUERY:
            /* Subselect-in-FROM: copy up from the subselect */
            if (attnum != InvalidAttrNumber)
            {
                TargetEntry *ste = get_tle_by_resno(rte->subquery->targetList,
                                                    attnum);
 
                if (ste == NULL || ste->resjunk)
                    elog(ERROR, "subquery %s does not have attribute %d",
                         rte->eref->aliasname, attnum);
                tle->resorigtbl = ste->resorigtbl;
                tle->resorigcol = ste->resorigcol;
            }
            break;
        case RTE_JOIN:
        case RTE_FUNCTION:
        case RTE_VALUES:
        case RTE_TABLEFUNC:
        case RTE_NAMEDTUPLESTORE:
        case RTE_RESULT:
            /* not a simple relation, leave it unmarked */
            break;
        case RTE_CTE:
 
            /*
             * CTE reference: copy up from the subquery, if possible. If the
             * RTE is a recursive self-reference then we can't do anything
             * because we haven't finished analyzing it yet. However, it's no
             * big loss because we must be down inside the recursive term of a
             * recursive CTE, and so any markings on the current targetlist
             * are not going to affect the results anyway.
             */
            if (attnum != InvalidAttrNumber && !rte->self_reference)
            {
                CommonTableExpr *cte = GetCTEForRTE(pstate, rte, netlevelsup);
                TargetEntry *ste;
                List       *tl = GetCTETargetList(cte);
                int         extra_cols = 0;
 
                /*
                 * RTE for CTE will already have the search and cycle columns
                 * added, but the subquery won't, so skip looking those up.
                 */
                if (cte->search_clause)
                    extra_cols += 1;
                if (cte->cycle_clause)
                    extra_cols += 2;
                if (extra_cols &&
                    attnum > list_length(tl) &&
                    attnum <= list_length(tl) + extra_cols)
                    break;
 
                ste = get_tle_by_resno(tl, attnum);
                if (ste == NULL || ste->resjunk)
                    elog(ERROR, "CTE %s does not have attribute %d",
                         rte->eref->aliasname, attnum);
                tle->resorigtbl = ste->resorigtbl;
                tle->resorigcol = ste->resorigcol;
            }
            break;
        case RTE_GROUP:
            /* We couldn't get here: the RTE_GROUP RTE has not been added */
            break;
    }
}

References attnum, elog, ERROR, get_tle_by_resno(), GetCTEForRTE(), GetCTETargetList, GetRTEByRangeTablePosn(), InvalidAttrNumber, IsA, list_length(), RTE_CTE, RTE_FUNCTION, RTE_GROUP, RTE_JOIN, RTE_NAMEDTUPLESTORE, RTE_RELATION, RTE_RESULT, RTE_SUBQUERY, RTE_TABLEFUNC, RTE_VALUES, RangeTblEntry::rtekind, RangeTblEntry::subquery, Query::targetList, Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by markTargetListOrigins().

markTargetListOrigins()

void markTargetListOrigins	(	ParseState *	pstate,
		List *	targetlist
	)

Definition at line 318 of file parse_target.c.

{
    ListCell   *l;
 
    foreach(l, targetlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
 
        markTargetListOrigin(pstate, tle, (Var *) tle->expr, 0);
    }
}

References TargetEntry::expr, lfirst, and markTargetListOrigin().

Referenced by transformReturningClause(), and transformSelectStmt().

resolveTargetListUnknowns()

void resolveTargetListUnknowns	(	ParseState *	pstate,
		List *	targetlist
	)

Definition at line 288 of file parse_target.c.

{
    ListCell   *l;
 
    foreach(l, targetlist)
    {
        TargetEntry *tle = (TargetEntry *) lfirst(l);
        Oid         restype = exprType((Node *) tle->expr);
 
        if (restype == UNKNOWNOID)
        {
            tle->expr = (Expr *) coerce_type(pstate, (Node *) tle->expr,
                                             restype, TEXTOID, -1,
                                             COERCION_IMPLICIT,
                                             COERCE_IMPLICIT_CAST,
                                             -1);
        }
    }
}

References COERCE_IMPLICIT_CAST, coerce_type(), COERCION_IMPLICIT, TargetEntry::expr, exprType(), and lfirst.

Referenced by transformReturningClause(), transformReturnStmt(), and transformSelectStmt().

transformAssignedExpr()

Expr * transformAssignedExpr	(	ParseState *	pstate,
		Expr *	expr,
		ParseExprKind	exprKind,
		const char *	colname,
		int	attrno,
		List *	indirection,
		int	location
	)

Definition at line 455 of file parse_target.c.

{
    Relation    rd = pstate->p_target_relation;
    Oid         type_id;        /* type of value provided */
    Oid         attrtype;       /* type of target column */
    int32       attrtypmod;
    Oid         attrcollation;  /* collation of target column */
    ParseExprKind sv_expr_kind;
 
    /*
     * Save and restore identity of expression type we're parsing.  We must
     * set p_expr_kind here because we can parse subscripts without going
     * through transformExpr().
     */
    Assert(exprKind != EXPR_KIND_NONE);
    sv_expr_kind = pstate->p_expr_kind;
    pstate->p_expr_kind = exprKind;
 
    Assert(rd != NULL);
    if (attrno <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("cannot assign to system column \"%s\"",
                        colname),
                 parser_errposition(pstate, location)));
    attrtype = attnumTypeId(rd, attrno);
    attrtypmod = TupleDescAttr(rd->rd_att, attrno - 1)->atttypmod;
    attrcollation = TupleDescAttr(rd->rd_att, attrno - 1)->attcollation;
 
    /*
     * If the expression is a DEFAULT placeholder, insert the attribute's
     * type/typmod/collation into it so that exprType etc will report the
     * right things.  (We expect that the eventually substituted default
     * expression will in fact have this type and typmod.  The collation
     * likely doesn't matter, but let's set it correctly anyway.)  Also,
     * reject trying to update a subfield or array element with DEFAULT, since
     * there can't be any default for portions of a column.
     */
    if (expr && IsA(expr, SetToDefault))
    {
        SetToDefault *def = (SetToDefault *) expr;
 
        def->typeId = attrtype;
        def->typeMod = attrtypmod;
        def->collation = attrcollation;
        if (indirection)
        {
            if (IsA(linitial(indirection), A_Indices))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot set an array element to DEFAULT"),
                         parser_errposition(pstate, location)));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot set a subfield to DEFAULT"),
                         parser_errposition(pstate, location)));
        }
    }
 
    /* Now we can use exprType() safely. */
    type_id = exprType((Node *) expr);
 
    /*
     * If there is indirection on the target column, prepare an array or
     * subfield assignment expression.  This will generate a new column value
     * that the source value has been inserted into, which can then be placed
     * in the new tuple constructed by INSERT or UPDATE.
     */
    if (indirection)
    {
        Node       *colVar;
 
        if (pstate->p_is_insert)
        {
            /*
             * The command is INSERT INTO table (col.something) ... so there
             * is not really a source value to work with. Insert a NULL
             * constant as the source value.
             */
            colVar = (Node *) makeNullConst(attrtype, attrtypmod,
                                            attrcollation);
        }
        else
        {
            /*
             * Build a Var for the column to be updated.
             */
            Var        *var;
 
            var = makeVar(pstate->p_target_nsitem->p_rtindex, attrno,
                          attrtype, attrtypmod, attrcollation, 0);
            var->location = location;
 
            colVar = (Node *) var;
        }
 
        expr = (Expr *)
            transformAssignmentIndirection(pstate,
                                           colVar,
                                           colname,
                                           false,
                                           attrtype,
                                           attrtypmod,
                                           attrcollation,
                                           indirection,
                                           list_head(indirection),
                                           (Node *) expr,
                                           COERCION_ASSIGNMENT,
                                           location);
    }
    else
    {
        /*
         * For normal non-qualified target column, do type checking and
         * coercion.
         */
        Node       *orig_expr = (Node *) expr;
 
        expr = (Expr *)
            coerce_to_target_type(pstate,
                                  orig_expr, type_id,
                                  attrtype, attrtypmod,
                                  COERCION_ASSIGNMENT,
                                  COERCE_IMPLICIT_CAST,
                                  -1);
        if (expr == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("column \"%s\" is of type %s"
                            " but expression is of type %s",
                            colname,
                            format_type_be(attrtype),
                            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 = sv_expr_kind;
 
    return expr;
}

References Assert(), attnumTypeId(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, ereport, errcode(), errhint(), errmsg(), ERROR, EXPR_KIND_NONE, exprLocation(), exprType(), format_type_be(), IsA, linitial, list_head(), Var::location, makeNullConst(), makeVar(), ParseState::p_expr_kind, ParseState::p_is_insert, ParseNamespaceItem::p_rtindex, ParseState::p_target_nsitem, ParseState::p_target_relation, parser_errposition(), RelationData::rd_att, transformAssignmentIndirection(), TupleDescAttr(), and SetToDefault::typeId.

Referenced by transformInsertRow(), and updateTargetListEntry().

transformAssignmentIndirection()

Node * transformAssignmentIndirection	(	ParseState *	pstate,
		Node *	basenode,
		const char *	targetName,
		bool	targetIsSubscripting,
		Oid	targetTypeId,
		int32	targetTypMod,
		Oid	targetCollation,
		List *	indirection,
		ListCell *	indirection_cell,
		Node *	rhs,
		CoercionContext	ccontext,
		int	location
	)

Definition at line 686 of file parse_target.c.

{
    Node       *result;
    List       *subscripts = NIL;
    ListCell   *i;
 
    if (indirection_cell && !basenode)
    {
        /*
         * Set up a substitution.  We abuse CaseTestExpr for this.  It's safe
         * to do so because the only nodes that will be above the CaseTestExpr
         * in the finished expression will be FieldStore and SubscriptingRef
         * nodes. (There could be other stuff in the tree, but it will be
         * within other child fields of those node types.)
         */
        CaseTestExpr *ctest = makeNode(CaseTestExpr);
 
        ctest->typeId = targetTypeId;
        ctest->typeMod = targetTypMod;
        ctest->collation = targetCollation;
        basenode = (Node *) ctest;
    }
 
    /*
     * We have to split any field-selection operations apart from
     * subscripting.  Adjacent A_Indices nodes have to be treated as a single
     * multidimensional subscript operation.
     */
    for_each_cell(i, indirection, indirection_cell)
    {
        Node       *n = lfirst(i);
 
        if (IsA(n, A_Indices))
            subscripts = lappend(subscripts, n);
        else if (IsA(n, A_Star))
        {
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("row expansion via \"*\" is not supported here"),
                     parser_errposition(pstate, location)));
        }
        else
        {
            FieldStore *fstore;
            Oid         baseTypeId;
            int32       baseTypeMod;
            Oid         typrelid;
            AttrNumber  attnum;
            Oid         fieldTypeId;
            int32       fieldTypMod;
            Oid         fieldCollation;
 
            Assert(IsA(n, String));
 
            /* process subscripts before this field selection */
            if (subscripts)
            {
                /* recurse, and then return because we're done */
                return transformAssignmentSubscripts(pstate,
                                                     basenode,
                                                     targetName,
                                                     targetTypeId,
                                                     targetTypMod,
                                                     targetCollation,
                                                     subscripts,
                                                     indirection,
                                                     i,
                                                     rhs,
                                                     ccontext,
                                                     location);
            }
 
            /* No subscripts, so can process field selection here */
 
            /*
             * Look up the composite type, accounting for possibility that
             * what we are given is a domain over composite.
             */
            baseTypeMod = targetTypMod;
            baseTypeId = getBaseTypeAndTypmod(targetTypeId, &baseTypeMod);
 
            typrelid = typeidTypeRelid(baseTypeId);
            if (!typrelid)
                ereport(ERROR,
                        (errcode(ERRCODE_DATATYPE_MISMATCH),
                         errmsg("cannot assign to field \"%s\" of column \"%s\" because its type %s is not a composite type",
                                strVal(n), targetName,
                                format_type_be(targetTypeId)),
                         parser_errposition(pstate, location)));
 
            attnum = get_attnum(typrelid, strVal(n));
            if (attnum == InvalidAttrNumber)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("cannot assign to field \"%s\" of column \"%s\" because there is no such column in data type %s",
                                strVal(n), targetName,
                                format_type_be(targetTypeId)),
                         parser_errposition(pstate, location)));
            if (attnum < 0)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_COLUMN),
                         errmsg("cannot assign to system column \"%s\"",
                                strVal(n)),
                         parser_errposition(pstate, location)));
 
            get_atttypetypmodcoll(typrelid, attnum,
                                  &fieldTypeId, &fieldTypMod, &fieldCollation);
 
            /* recurse to create appropriate RHS for field assign */
            rhs = transformAssignmentIndirection(pstate,
                                                 NULL,
                                                 strVal(n),
                                                 false,
                                                 fieldTypeId,
                                                 fieldTypMod,
                                                 fieldCollation,
                                                 indirection,
                                                 lnext(indirection, i),
                                                 rhs,
                                                 ccontext,
                                                 location);
 
            /* and build a FieldStore node */
            fstore = makeNode(FieldStore);
            fstore->arg = (Expr *) basenode;
            fstore->newvals = list_make1(rhs);
            fstore->fieldnums = list_make1_int(attnum);
            fstore->resulttype = baseTypeId;
 
            /*
             * If target is a domain, apply constraints.  Notice that this
             * isn't totally right: the expression tree we build would check
             * the domain's constraints on a composite value with only this
             * one field populated or updated, possibly leading to an unwanted
             * failure.  The rewriter will merge together any subfield
             * assignments to the same table column, resulting in the domain's
             * constraints being checked only once after we've assigned to all
             * the fields that the INSERT or UPDATE means to.
             */
            if (baseTypeId != targetTypeId)
                return coerce_to_domain((Node *) fstore,
                                        baseTypeId, baseTypeMod,
                                        targetTypeId,
                                        COERCION_IMPLICIT,
                                        COERCE_IMPLICIT_CAST,
                                        location,
                                        false);
 
            return (Node *) fstore;
        }
    }
 
    /* process trailing subscripts, if any */
    if (subscripts)
    {
        /* recurse, and then return because we're done */
        return transformAssignmentSubscripts(pstate,
                                             basenode,
                                             targetName,
                                             targetTypeId,
                                             targetTypMod,
                                             targetCollation,
                                             subscripts,
                                             indirection,
                                             NULL,
                                             rhs,
                                             ccontext,
                                             location);
    }
 
    /* base case: just coerce RHS to match target type ID */
 
    result = coerce_to_target_type(pstate,
                                   rhs, exprType(rhs),
                                   targetTypeId, targetTypMod,
                                   ccontext,
                                   COERCE_IMPLICIT_CAST,
                                   -1);
    if (result == NULL)
    {
        if (targetIsSubscripting)
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("subscripted assignment to \"%s\" requires type %s"
                            " but expression is of type %s",
                            targetName,
                            format_type_be(targetTypeId),
                            format_type_be(exprType(rhs))),
                     errhint("You will need to rewrite or cast the expression."),
                     parser_errposition(pstate, location)));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_DATATYPE_MISMATCH),
                     errmsg("subfield \"%s\" is of type %s"
                            " but expression is of type %s",
                            targetName,
                            format_type_be(targetTypeId),
                            format_type_be(exprType(rhs))),
                     errhint("You will need to rewrite or cast the expression."),
                     parser_errposition(pstate, location)));
    }
 
    return result;
}

References FieldStore::arg, Assert(), attnum, COERCE_IMPLICIT_CAST, coerce_to_domain(), coerce_to_target_type(), COERCION_IMPLICIT, ereport, errcode(), errhint(), errmsg(), ERROR, exprType(), for_each_cell, format_type_be(), get_attnum(), get_atttypetypmodcoll(), getBaseTypeAndTypmod(), i, InvalidAttrNumber, IsA, lappend(), lfirst, list_make1, list_make1_int, lnext(), makeNode, FieldStore::newvals, NIL, parser_errposition(), strVal, transformAssignmentIndirection(), transformAssignmentSubscripts(), CaseTestExpr::typeId, and typeidTypeRelid().

Referenced by transformAssignedExpr(), transformAssignmentIndirection(), transformAssignmentSubscripts(), and transformPLAssignStmt().

transformAssignmentSubscripts()

static Node * transformAssignmentSubscripts ( ParseState *  pstate, Node *  basenode, const char *  targetName, Oid  targetTypeId, int32  targetTypMod, Oid  targetCollation, List *  subscripts, List *  indirection, ListCell *  next_indirection, Node *  rhs, CoercionContext  ccontext, int  location  )

static

Definition at line 906 of file parse_target.c.

{
    Node       *result;
    SubscriptingRef *sbsref;
    Oid         containerType;
    int32       containerTypMod;
    Oid         typeNeeded;
    int32       typmodNeeded;
    Oid         collationNeeded;
 
    Assert(subscripts != NIL);
 
    /* Identify the actual container type involved */
    containerType = targetTypeId;
    containerTypMod = targetTypMod;
    transformContainerType(&containerType, &containerTypMod);
 
    /* Process subscripts and identify required type for RHS */
    sbsref = transformContainerSubscripts(pstate,
                                          basenode,
                                          containerType,
                                          containerTypMod,
                                          subscripts,
                                          true);
 
    typeNeeded = sbsref->refrestype;
    typmodNeeded = sbsref->reftypmod;
 
    /*
     * Container normally has same collation as its elements, but there's an
     * exception: we might be subscripting a domain over a container type.  In
     * that case use collation of the base type.  (This is shaky for arbitrary
     * subscripting semantics, but it doesn't matter all that much since we
     * only use this to label the collation of a possible CaseTestExpr.)
     */
    if (containerType == targetTypeId)
        collationNeeded = targetCollation;
    else
        collationNeeded = get_typcollation(containerType);
 
    /* recurse to create appropriate RHS for container assign */
    rhs = transformAssignmentIndirection(pstate,
                                         NULL,
                                         targetName,
                                         true,
                                         typeNeeded,
                                         typmodNeeded,
                                         collationNeeded,
                                         indirection,
                                         next_indirection,
                                         rhs,
                                         ccontext,
                                         location);
 
    /*
     * Insert the already-properly-coerced RHS into the SubscriptingRef.  Then
     * set refrestype and reftypmod back to the container type's values.
     */
    sbsref->refassgnexpr = (Expr *) rhs;
    sbsref->refrestype = containerType;
    sbsref->reftypmod = containerTypMod;
 
    result = (Node *) sbsref;
 
    /*
     * If target was a domain over container, need to coerce up to the domain.
     * As in transformAssignmentIndirection, this coercion is premature if the
     * query assigns to multiple elements of the container; but we'll fix that
     * during query rewrite.
     */
    if (containerType != targetTypeId)
    {
        Oid         resulttype = exprType(result);
 
        result = coerce_to_target_type(pstate,
                                       result, resulttype,
                                       targetTypeId, targetTypMod,
                                       ccontext,
                                       COERCE_IMPLICIT_CAST,
                                       -1);
        /* can fail if we had int2vector/oidvector, but not for true domains */
        if (result == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_CANNOT_COERCE),
                     errmsg("cannot cast type %s to %s",
                            format_type_be(resulttype),
                            format_type_be(targetTypeId)),
                     parser_errposition(pstate, location)));
    }
 
    return result;
}

References Assert(), COERCE_IMPLICIT_CAST, coerce_to_target_type(), ereport, errcode(), errmsg(), ERROR, exprType(), format_type_be(), get_typcollation(), NIL, parser_errposition(), SubscriptingRef::refassgnexpr, transformAssignmentIndirection(), transformContainerSubscripts(), and transformContainerType().

Referenced by transformAssignmentIndirection().

transformExpressionList()

List * transformExpressionList	(	ParseState *	pstate,
		List *	exprlist,
		ParseExprKind	exprKind,
		bool	allowDefault
	)

Definition at line 220 of file parse_target.c.

{
    List       *result = NIL;
    ListCell   *lc;
 
    foreach(lc, exprlist)
    {
        Node       *e = (Node *) lfirst(lc);
 
        /*
         * Check for "something.*".  Depending on the complexity of the
         * "something", the star could appear as the last field in ColumnRef,
         * or as the last indirection item in A_Indirection.
         */
        if (IsA(e, ColumnRef))
        {
            ColumnRef  *cref = (ColumnRef *) e;
 
            if (IsA(llast(cref->fields), A_Star))
            {
                /* It is something.*, expand into multiple items */
                result = list_concat(result,
                                     ExpandColumnRefStar(pstate, cref,
                                                         false));
                continue;
            }
        }
        else if (IsA(e, A_Indirection))
        {
            A_Indirection *ind = (A_Indirection *) e;
 
            if (IsA(llast(ind->indirection), A_Star))
            {
                /* It is something.*, expand into multiple items */
                result = list_concat(result,
                                     ExpandIndirectionStar(pstate, ind,
                                                           false, exprKind));
                continue;
            }
        }
 
        /*
         * Not "something.*", so transform as a single expression.  If it's a
         * SetToDefault node and we should allow that, pass it through
         * unmodified.  (transformExpr will throw the appropriate error if
         * we're disallowing it.)
         */
        if (allowDefault && IsA(e, SetToDefault))
             /* do nothing */ ;
        else
            e = transformExpr(pstate, e, exprKind);
 
        result = lappend(result, e);
    }
 
    return result;
}

References ExpandColumnRefStar(), ExpandIndirectionStar(), ColumnRef::fields, IsA, lappend(), lfirst, list_concat(), llast, NIL, and transformExpr().

Referenced by transformMergeStmt(), transformRowExpr(), and transformValuesClause().

transformTargetEntry()

TargetEntry * transformTargetEntry	(	ParseState *	pstate,
		Node *	node,
		Node *	expr,
		ParseExprKind	exprKind,
		char *	colname,
		bool	resjunk
	)

Definition at line 75 of file parse_target.c.

{
    /* Transform the node if caller didn't do it already */
    if (expr == NULL)
    {
        /*
         * If it's a SetToDefault node and we should allow that, pass it
         * through unmodified.  (transformExpr will throw the appropriate
         * error if we're disallowing it.)
         */
        if (exprKind == EXPR_KIND_UPDATE_SOURCE && IsA(node, SetToDefault))
            expr = node;
        else
            expr = transformExpr(pstate, node, exprKind);
    }
 
    if (colname == NULL && !resjunk)
    {
        /*
         * Generate a suitable column name for a column without any explicit
         * 'AS ColumnName' clause.
         */
        colname = FigureColname(node);
    }
 
    return makeTargetEntry((Expr *) expr,
                           (AttrNumber) pstate->p_next_resno++,
                           colname,
                           resjunk);
}

References EXPR_KIND_UPDATE_SOURCE, FigureColname(), IsA, makeTargetEntry(), ParseState::p_next_resno, and transformExpr().

Referenced by findTargetlistEntrySQL99(), and transformTargetList().

transformTargetList()

List * transformTargetList	(	ParseState *	pstate,
		List *	targetlist,
		ParseExprKind	exprKind
	)

Definition at line 121 of file parse_target.c.

{
    List       *p_target = NIL;
    bool        expand_star;
    ListCell   *o_target;
 
    /* Shouldn't have any leftover multiassign items at start */
    Assert(pstate->p_multiassign_exprs == NIL);
 
    /* Expand "something.*" in SELECT and RETURNING, but not UPDATE */
    expand_star = (exprKind != EXPR_KIND_UPDATE_SOURCE);
 
    foreach(o_target, targetlist)
    {
        ResTarget  *res = (ResTarget *) lfirst(o_target);
 
        /*
         * Check for "something.*".  Depending on the complexity of the
         * "something", the star could appear as the last field in ColumnRef,
         * or as the last indirection item in A_Indirection.
         */
        if (expand_star)
        {
            if (IsA(res->val, ColumnRef))
            {
                ColumnRef  *cref = (ColumnRef *) res->val;
 
                if (IsA(llast(cref->fields), A_Star))
                {
                    /* It is something.*, expand into multiple items */
                    p_target = list_concat(p_target,
                                           ExpandColumnRefStar(pstate,
                                                               cref,
                                                               true));
                    continue;
                }
            }
            else if (IsA(res->val, A_Indirection))
            {
                A_Indirection *ind = (A_Indirection *) res->val;
 
                if (IsA(llast(ind->indirection), A_Star))
                {
                    /* It is something.*, expand into multiple items */
                    p_target = list_concat(p_target,
                                           ExpandIndirectionStar(pstate,
                                                                 ind,
                                                                 true,
                                                                 exprKind));
                    continue;
                }
            }
        }
 
        /*
         * Not "something.*", or we want to treat that as a plain whole-row
         * variable, so transform as a single expression
         */
        p_target = lappend(p_target,
                           transformTargetEntry(pstate,
                                                res->val,
                                                NULL,
                                                exprKind,
                                                res->name,
                                                false));
    }
 
    /*
     * If any multiassign resjunk items were created, attach them to the end
     * of the targetlist.  This should only happen in an UPDATE tlist.  We
     * don't need to worry about numbering of these items; transformUpdateStmt
     * will set their resnos.
     */
    if (pstate->p_multiassign_exprs)
    {
        Assert(exprKind == EXPR_KIND_UPDATE_SOURCE);
        p_target = list_concat(p_target, pstate->p_multiassign_exprs);
        pstate->p_multiassign_exprs = NIL;
    }
 
    return p_target;
}

References Assert(), ExpandColumnRefStar(), ExpandIndirectionStar(), EXPR_KIND_UPDATE_SOURCE, ColumnRef::fields, if(), IsA, lappend(), lfirst, list_concat(), llast, ResTarget::name, NIL, ParseState::p_multiassign_exprs, transformTargetEntry(), and ResTarget::val.

Referenced by transformPLAssignStmt(), transformReturningClause(), transformSelectStmt(), and transformUpdateTargetList().

updateTargetListEntry()

void updateTargetListEntry	(	ParseState *	pstate,
		TargetEntry *	tle,
		char *	colname,
		int	attrno,
		List *	indirection,
		int	location
	)

Definition at line 622 of file parse_target.c.

{
    /* Fix up expression as needed */
    tle->expr = transformAssignedExpr(pstate,
                                      tle->expr,
                                      EXPR_KIND_UPDATE_TARGET,
                                      colname,
                                      attrno,
                                      indirection,
                                      location);
 
    /*
     * Set the resno to identify the target column --- the rewriter and
     * planner depend on this.  We also set the resname to identify the target
     * column, but this is only for debugging purposes; it should not be
     * relied on.  (In particular, it might be out of date in a stored rule.)
     */
    tle->resno = (AttrNumber) attrno;
    tle->resname = colname;
}

References TargetEntry::expr, EXPR_KIND_UPDATE_TARGET, TargetEntry::resno, and transformAssignedExpr().

Referenced by transformUpdateTargetList().