rewriteHandler.h File Reference

#include "nodes/parsenodes.h"
#include "utils/relcache.h"

Include dependency graph for rewriteHandler.h:

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

Go to the source code of this file.

Functions
List *	QueryRewrite (Query *parsetree)
void	AcquireRewriteLocks (Query *parsetree, bool forExecute, bool forUpdatePushedDown)
Node *	build_column_default (Relation rel, int attrno)
Query *	get_view_query (Relation view)
bool	view_has_instead_trigger (Relation view, CmdType event, List *mergeActionList)
const char *	view_query_is_auto_updatable (Query *viewquery, bool check_cols)
int	relation_is_updatable (Oid reloid, List *outer_reloids, bool include_triggers, Bitmapset *include_cols)
void	error_view_not_updatable (Relation view, CmdType command, List *mergeActionList, const char *detail)

Function Documentation

AcquireRewriteLocks()

void AcquireRewriteLocks	(	Query *	parsetree,
		bool	forExecute,
		bool	forUpdatePushedDown
	)

Definition at line 139 of file rewriteHandler.c.

{
    ListCell   *l;
    int         rt_index;
    acquireLocksOnSubLinks_context context;
 
    context.for_execute = forExecute;
 
    /*
     * First, process RTEs of the current query level.
     */
    rt_index = 0;
    foreach(l, parsetree->rtable)
    {
        RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
        Relation    rel;
        LOCKMODE    lockmode;
        List       *newaliasvars;
        Index       curinputvarno;
        RangeTblEntry *curinputrte;
        ListCell   *ll;
 
        ++rt_index;
        switch (rte->rtekind)
        {
            case RTE_RELATION:
 
                /*
                 * Grab the appropriate lock type for the relation, and do not
                 * release it until end of transaction.  This protects the
                 * rewriter, planner, and executor against schema changes
                 * mid-query.
                 *
                 * If forExecute is false, ignore rellockmode and just use
                 * AccessShareLock.
                 */
                if (!forExecute)
                    lockmode = AccessShareLock;
                else if (forUpdatePushedDown)
                {
                    /* Upgrade RTE's lock mode to reflect pushed-down lock */
                    if (rte->rellockmode == AccessShareLock)
                        rte->rellockmode = RowShareLock;
                    lockmode = rte->rellockmode;
                }
                else
                    lockmode = rte->rellockmode;
 
                rel = table_open(rte->relid, lockmode);
 
                /*
                 * While we have the relation open, update the RTE's relkind,
                 * just in case it changed since this rule was made.
                 */
                rte->relkind = rel->rd_rel->relkind;
 
                table_close(rel, NoLock);
                break;
 
            case RTE_JOIN:
 
                /*
                 * Scan the join's alias var list to see if any columns have
                 * been dropped, and if so replace those Vars with null
                 * pointers.
                 *
                 * Since a join has only two inputs, we can expect to see
                 * multiple references to the same input RTE; optimize away
                 * multiple fetches.
                 */
                newaliasvars = NIL;
                curinputvarno = 0;
                curinputrte = NULL;
                foreach(ll, rte->joinaliasvars)
                {
                    Var        *aliasitem = (Var *) lfirst(ll);
                    Var        *aliasvar = aliasitem;
 
                    /* Look through any implicit coercion */
                    aliasvar = (Var *) strip_implicit_coercions((Node *) aliasvar);
 
                    /*
                     * If the list item isn't a simple Var, then it must
                     * represent a merged column, ie a USING column, and so it
                     * couldn't possibly be dropped, since it's referenced in
                     * the join clause.  (Conceivably it could also be a null
                     * pointer already?  But that's OK too.)
                     */
                    if (aliasvar && IsA(aliasvar, Var))
                    {
                        /*
                         * The elements of an alias list have to refer to
                         * earlier RTEs of the same rtable, because that's the
                         * order the planner builds things in.  So we already
                         * processed the referenced RTE, and so it's safe to
                         * use get_rte_attribute_is_dropped on it. (This might
                         * not hold after rewriting or planning, but it's OK
                         * to assume here.)
                         */
                        Assert(aliasvar->varlevelsup == 0);
                        if (aliasvar->varno != curinputvarno)
                        {
                            curinputvarno = aliasvar->varno;
                            if (curinputvarno >= rt_index)
                                elog(ERROR, "unexpected varno %d in JOIN RTE %d",
                                     curinputvarno, rt_index);
                            curinputrte = rt_fetch(curinputvarno,
                                                   parsetree->rtable);
                        }
                        if (get_rte_attribute_is_dropped(curinputrte,
                                                         aliasvar->varattno))
                        {
                            /* Replace the join alias item with a NULL */
                            aliasitem = NULL;
                        }
                    }
                    newaliasvars = lappend(newaliasvars, aliasitem);
                }
                rte->joinaliasvars = newaliasvars;
                break;
 
            case RTE_SUBQUERY:
 
                /*
                 * The subquery RTE itself is all right, but we have to
                 * recurse to process the represented subquery.
                 */
                AcquireRewriteLocks(rte->subquery,
                                    forExecute,
                                    (forUpdatePushedDown ||
                                     get_parse_rowmark(parsetree, rt_index) != NULL));
                break;
 
            default:
                /* ignore other types of RTEs */
                break;
        }
    }
 
    /* Recurse into subqueries in WITH */
    foreach(l, parsetree->cteList)
    {
        CommonTableExpr *cte = (CommonTableExpr *) lfirst(l);
 
        AcquireRewriteLocks((Query *) cte->ctequery, forExecute, false);
    }
 
    /*
     * Recurse into sublink subqueries, too.  But we already did the ones in
     * the rtable and cteList.
     */
    if (parsetree->hasSubLinks)
        query_tree_walker(parsetree, acquireLocksOnSubLinks, &context,
                          QTW_IGNORE_RC_SUBQUERIES);
}

References AccessShareLock, acquireLocksOnSubLinks(), Assert, context, Query::cteList, CommonTableExpr::ctequery, elog, ERROR, get_parse_rowmark(), get_rte_attribute_is_dropped(), IsA, lappend(), lfirst, NIL, NoLock, QTW_IGNORE_RC_SUBQUERIES, query_tree_walker, RelationData::rd_rel, RangeTblEntry::relid, RowShareLock, rt_fetch, Query::rtable, RTE_JOIN, RTE_RELATION, RTE_SUBQUERY, RangeTblEntry::rtekind, strip_implicit_coercions(), RangeTblEntry::subquery, table_close(), table_open(), Var::varattno, Var::varlevelsup, and Var::varno.

Referenced by acquireLocksOnSubLinks(), ApplyRetrieveRule(), fmgr_sql_validator(), get_query_def(), init_sql_fcache(), inline_set_returning_function(), make_ruledef(), print_function_sqlbody(), refresh_matview_datafill(), and rewriteRuleAction().

build_column_default()

Node* build_column_default	(	Relation	rel,
		int	attrno
	)

Definition at line 1223 of file rewriteHandler.c.

{
    TupleDesc   rd_att = rel->rd_att;
    Form_pg_attribute att_tup = TupleDescAttr(rd_att, attrno - 1);
    Oid         atttype = att_tup->atttypid;
    int32       atttypmod = att_tup->atttypmod;
    Node       *expr = NULL;
    Oid         exprtype;
 
    if (att_tup->attidentity)
    {
        NextValueExpr *nve = makeNode(NextValueExpr);
 
        nve->seqid = getIdentitySequence(rel, attrno, false);
        nve->typeId = att_tup->atttypid;
 
        return (Node *) nve;
    }
 
    /*
     * If relation has a default for this column, fetch that expression.
     */
    if (att_tup->atthasdef)
    {
        expr = TupleDescGetDefault(rd_att, attrno);
        if (expr == NULL)
            elog(ERROR, "default expression not found for attribute %d of relation \"%s\"",
                 attrno, RelationGetRelationName(rel));
    }
 
    /*
     * No per-column default, so look for a default for the type itself.  But
     * not for generated columns.
     */
    if (expr == NULL && !att_tup->attgenerated)
        expr = get_typdefault(atttype);
 
    if (expr == NULL)
        return NULL;            /* No default anywhere */
 
    /*
     * Make sure the value is coerced to the target column type; this will
     * generally be true already, but there seem to be some corner cases
     * involving domain defaults where it might not be true. This should match
     * the parser's processing of non-defaulted expressions --- see
     * transformAssignedExpr().
     */
    exprtype = exprType(expr);
 
    expr = coerce_to_target_type(NULL,  /* no UNKNOWN params here */
                                 expr, exprtype,
                                 atttype, atttypmod,
                                 COERCION_ASSIGNMENT,
                                 COERCE_IMPLICIT_CAST,
                                 -1);
    if (expr == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_DATATYPE_MISMATCH),
                 errmsg("column \"%s\" is of type %s"
                        " but default expression is of type %s",
                        NameStr(att_tup->attname),
                        format_type_be(atttype),
                        format_type_be(exprtype)),
                 errhint("You will need to rewrite or cast the expression.")));
 
    return expr;
}

References COERCE_IMPLICIT_CAST, coerce_to_target_type(), COERCION_ASSIGNMENT, elog, ereport, errcode(), errhint(), errmsg(), ERROR, exprType(), format_type_be(), get_typdefault(), getIdentitySequence(), makeNode, NameStr, RelationData::rd_att, RelationGetRelationName, NextValueExpr::seqid, TupleDescAttr, TupleDescGetDefault(), and NextValueExpr::typeId.

Referenced by ATExecAddColumn(), ATExecAlterColumnType(), ATExecSetExpression(), BeginCopyFrom(), ExecInitStoredGenerated(), rewriteTargetListIU(), rewriteValuesRTE(), and slot_fill_defaults().

error_view_not_updatable()

void error_view_not_updatable	(	Relation	view,
		CmdType	command,
		List *	mergeActionList,
		const char *	detail
	)

Definition at line 3067 of file rewriteHandler.c.

{
    TriggerDesc *trigDesc = view->trigdesc;
 
    switch (command)
    {
        case CMD_INSERT:
            ereport(ERROR,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("cannot insert into view \"%s\"",
                           RelationGetRelationName(view)),
                    detail ? errdetail_internal("%s", _(detail)) : 0,
                    errhint("To enable inserting into the view, provide an INSTEAD OF INSERT trigger or an unconditional ON INSERT DO INSTEAD rule."));
            break;
        case CMD_UPDATE:
            ereport(ERROR,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("cannot update view \"%s\"",
                           RelationGetRelationName(view)),
                    detail ? errdetail_internal("%s", _(detail)) : 0,
                    errhint("To enable updating the view, provide an INSTEAD OF UPDATE trigger or an unconditional ON UPDATE DO INSTEAD rule."));
            break;
        case CMD_DELETE:
            ereport(ERROR,
                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                    errmsg("cannot delete from view \"%s\"",
                           RelationGetRelationName(view)),
                    detail ? errdetail_internal("%s", _(detail)) : 0,
                    errhint("To enable deleting from the view, provide an INSTEAD OF DELETE trigger or an unconditional ON DELETE DO INSTEAD rule."));
            break;
        case CMD_MERGE:
 
            /*
             * Note that the error hints here differ from above, since MERGE
             * doesn't support rules.
             */
            foreach_node(MergeAction, action, mergeActionList)
            {
                switch (action->commandType)
                {
                    case CMD_INSERT:
                        if (!trigDesc || !trigDesc->trig_insert_instead_row)
                            ereport(ERROR,
                                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                    errmsg("cannot insert into view \"%s\"",
                                           RelationGetRelationName(view)),
                                    detail ? errdetail_internal("%s", _(detail)) : 0,
                                    errhint("To enable inserting into the view using MERGE, provide an INSTEAD OF INSERT trigger."));
                        break;
                    case CMD_UPDATE:
                        if (!trigDesc || !trigDesc->trig_update_instead_row)
                            ereport(ERROR,
                                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                    errmsg("cannot update view \"%s\"",
                                           RelationGetRelationName(view)),
                                    detail ? errdetail_internal("%s", _(detail)) : 0,
                                    errhint("To enable updating the view using MERGE, provide an INSTEAD OF UPDATE trigger."));
                        break;
                    case CMD_DELETE:
                        if (!trigDesc || !trigDesc->trig_delete_instead_row)
                            ereport(ERROR,
                                    errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                                    errmsg("cannot delete from view \"%s\"",
                                           RelationGetRelationName(view)),
                                    detail ? errdetail_internal("%s", _(detail)) : 0,
                                    errhint("To enable deleting from the view using MERGE, provide an INSTEAD OF DELETE trigger."));
                        break;
                    case CMD_NOTHING:
                        break;
                    default:
                        elog(ERROR, "unrecognized commandType: %d", action->commandType);
                        break;
                }
            }
            break;
        default:
            elog(ERROR, "unrecognized CmdType: %d", (int) command);
            break;
    }
}

References _, generate_unaccent_rules::action, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_UPDATE, elog, ereport, errcode(), errdetail_internal(), errhint(), errmsg(), ERROR, foreach_node, RelationGetRelationName, TriggerDesc::trig_delete_instead_row, TriggerDesc::trig_insert_instead_row, TriggerDesc::trig_update_instead_row, and RelationData::trigdesc.

Referenced by CheckValidResultRel(), RewriteQuery(), and rewriteTargetView().

get_view_query()

Query* get_view_query

(

Relation

view

)

Definition at line 2430 of file rewriteHandler.c.

{
    int         i;
 
    Assert(view->rd_rel->relkind == RELKIND_VIEW);
 
    for (i = 0; i < view->rd_rules->numLocks; i++)
    {
        RewriteRule *rule = view->rd_rules->rules[i];
 
        if (rule->event == CMD_SELECT)
        {
            /* A _RETURN rule should have only one action */
            if (list_length(rule->actions) != 1)
                elog(ERROR, "invalid _RETURN rule action specification");
 
            return (Query *) linitial(rule->actions);
        }
    }
 
    elog(ERROR, "failed to find _RETURN rule for view");
    return NULL;                /* keep compiler quiet */
}

References Assert, CMD_SELECT, elog, ERROR, i, linitial, list_length(), RuleLock::numLocks, RelationData::rd_rel, RelationData::rd_rules, and RuleLock::rules.

Referenced by ATExecSetRelOptions(), LockViewRecurse(), relation_is_updatable(), and rewriteTargetView().

QueryRewrite()

List* QueryRewrite

(

Query *

parsetree

)

Definition at line 4361 of file rewriteHandler.c.

{
    uint64      input_query_id = parsetree->queryId;
    List       *querylist;
    List       *results;
    ListCell   *l;
    CmdType     origCmdType;
    bool        foundOriginalQuery;
    Query      *lastInstead;
 
    /*
     * This function is only applied to top-level original queries
     */
    Assert(parsetree->querySource == QSRC_ORIGINAL);
    Assert(parsetree->canSetTag);
 
    /*
     * Step 1
     *
     * Apply all non-SELECT rules possibly getting 0 or many queries
     */
    querylist = RewriteQuery(parsetree, NIL, 0);
 
    /*
     * Step 2
     *
     * Apply all the RIR rules on each query
     *
     * This is also a handy place to mark each query with the original queryId
     */
    results = NIL;
    foreach(l, querylist)
    {
        Query      *query = (Query *) lfirst(l);
 
        query = fireRIRrules(query, NIL);
 
        query->queryId = input_query_id;
 
        results = lappend(results, query);
    }
 
    /*
     * Step 3
     *
     * Determine which, if any, of the resulting queries is supposed to set
     * the command-result tag; and update the canSetTag fields accordingly.
     *
     * If the original query is still in the list, it sets the command tag.
     * Otherwise, the last INSTEAD query of the same kind as the original is
     * allowed to set the tag.  (Note these rules can leave us with no query
     * setting the tag.  The tcop code has to cope with this by setting up a
     * default tag based on the original un-rewritten query.)
     *
     * The Asserts verify that at most one query in the result list is marked
     * canSetTag.  If we aren't checking asserts, we can fall out of the loop
     * as soon as we find the original query.
     */
    origCmdType = parsetree->commandType;
    foundOriginalQuery = false;
    lastInstead = NULL;
 
    foreach(l, results)
    {
        Query      *query = (Query *) lfirst(l);
 
        if (query->querySource == QSRC_ORIGINAL)
        {
            Assert(query->canSetTag);
            Assert(!foundOriginalQuery);
            foundOriginalQuery = true;
#ifndef USE_ASSERT_CHECKING
            break;
#endif
        }
        else
        {
            Assert(!query->canSetTag);
            if (query->commandType == origCmdType &&
                (query->querySource == QSRC_INSTEAD_RULE ||
                 query->querySource == QSRC_QUAL_INSTEAD_RULE))
                lastInstead = query;
        }
    }
 
    if (!foundOriginalQuery && lastInstead != NULL)
        lastInstead->canSetTag = true;
 
    return results;
}

References Assert, Query::commandType, fireRIRrules(), lappend(), lfirst, NIL, QSRC_INSTEAD_RULE, QSRC_ORIGINAL, QSRC_QUAL_INSTEAD_RULE, and RewriteQuery().

Referenced by ExecCreateTableAs(), ExplainOneUtility(), ExplainQuery(), PerformCursorOpen(), pg_rewrite_query(), and refresh_matview_datafill().

relation_is_updatable()

int relation_is_updatable	(	Oid	reloid,
		List *	outer_reloids,
		bool	include_triggers,
		Bitmapset *	include_cols
	)

Definition at line 2812 of file rewriteHandler.c.

{
    int         events = 0;
    Relation    rel;
    RuleLock   *rulelocks;
 
#define ALL_EVENTS ((1 << CMD_INSERT) | (1 << CMD_UPDATE) | (1 << CMD_DELETE))
 
    /* Since this function recurses, it could be driven to stack overflow */
    check_stack_depth();
 
    rel = try_relation_open(reloid, AccessShareLock);
 
    /*
     * If the relation doesn't exist, return zero rather than throwing an
     * error.  This is helpful since scanning an information_schema view under
     * MVCC rules can result in referencing rels that have actually been
     * deleted already.
     */
    if (rel == NULL)
        return 0;
 
    /* If we detect a recursive view, report that it is not updatable */
    if (list_member_oid(outer_reloids, RelationGetRelid(rel)))
    {
        relation_close(rel, AccessShareLock);
        return 0;
    }
 
    /* If the relation is a table, it is always updatable */
    if (rel->rd_rel->relkind == RELKIND_RELATION ||
        rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
    {
        relation_close(rel, AccessShareLock);
        return ALL_EVENTS;
    }
 
    /* Look for unconditional DO INSTEAD rules, and note supported events */
    rulelocks = rel->rd_rules;
    if (rulelocks != NULL)
    {
        int         i;
 
        for (i = 0; i < rulelocks->numLocks; i++)
        {
            if (rulelocks->rules[i]->isInstead &&
                rulelocks->rules[i]->qual == NULL)
            {
                events |= ((1 << rulelocks->rules[i]->event) & ALL_EVENTS);
            }
        }
 
        /* If we have rules for all events, we're done */
        if (events == ALL_EVENTS)
        {
            relation_close(rel, AccessShareLock);
            return events;
        }
    }
 
    /* Similarly look for INSTEAD OF triggers, if they are to be included */
    if (include_triggers)
    {
        TriggerDesc *trigDesc = rel->trigdesc;
 
        if (trigDesc)
        {
            if (trigDesc->trig_insert_instead_row)
                events |= (1 << CMD_INSERT);
            if (trigDesc->trig_update_instead_row)
                events |= (1 << CMD_UPDATE);
            if (trigDesc->trig_delete_instead_row)
                events |= (1 << CMD_DELETE);
 
            /* If we have triggers for all events, we're done */
            if (events == ALL_EVENTS)
            {
                relation_close(rel, AccessShareLock);
                return events;
            }
        }
    }
 
    /* If this is a foreign table, check which update events it supports */
    if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
    {
        FdwRoutine *fdwroutine = GetFdwRoutineForRelation(rel, false);
 
        if (fdwroutine->IsForeignRelUpdatable != NULL)
            events |= fdwroutine->IsForeignRelUpdatable(rel);
        else
        {
            /* Assume presence of executor functions is sufficient */
            if (fdwroutine->ExecForeignInsert != NULL)
                events |= (1 << CMD_INSERT);
            if (fdwroutine->ExecForeignUpdate != NULL)
                events |= (1 << CMD_UPDATE);
            if (fdwroutine->ExecForeignDelete != NULL)
                events |= (1 << CMD_DELETE);
        }
 
        relation_close(rel, AccessShareLock);
        return events;
    }
 
    /* Check if this is an automatically updatable view */
    if (rel->rd_rel->relkind == RELKIND_VIEW)
    {
        Query      *viewquery = get_view_query(rel);
 
        if (view_query_is_auto_updatable(viewquery, false) == NULL)
        {
            Bitmapset  *updatable_cols;
            int         auto_events;
            RangeTblRef *rtr;
            RangeTblEntry *base_rte;
            Oid         baseoid;
 
            /*
             * Determine which of the view's columns are updatable. If there
             * are none within the set of columns we are looking at, then the
             * view doesn't support INSERT/UPDATE, but it may still support
             * DELETE.
             */
            view_cols_are_auto_updatable(viewquery, NULL,
                                         &updatable_cols, NULL);
 
            if (include_cols != NULL)
                updatable_cols = bms_int_members(updatable_cols, include_cols);
 
            if (bms_is_empty(updatable_cols))
                auto_events = (1 << CMD_DELETE);    /* May support DELETE */
            else
                auto_events = ALL_EVENTS;   /* May support all events */
 
            /*
             * The base relation must also support these update commands.
             * Tables are always updatable, but for any other kind of base
             * relation we must do a recursive check limited to the columns
             * referenced by the locally updatable columns in this view.
             */
            rtr = (RangeTblRef *) linitial(viewquery->jointree->fromlist);
            base_rte = rt_fetch(rtr->rtindex, viewquery->rtable);
            Assert(base_rte->rtekind == RTE_RELATION);
 
            if (base_rte->relkind != RELKIND_RELATION &&
                base_rte->relkind != RELKIND_PARTITIONED_TABLE)
            {
                baseoid = base_rte->relid;
                outer_reloids = lappend_oid(outer_reloids,
                                            RelationGetRelid(rel));
                include_cols = adjust_view_column_set(updatable_cols,
                                                      viewquery->targetList);
                auto_events &= relation_is_updatable(baseoid,
                                                     outer_reloids,
                                                     include_triggers,
                                                     include_cols);
                outer_reloids = list_delete_last(outer_reloids);
            }
            events |= auto_events;
        }
    }
 
    /* If we reach here, the relation may support some update commands */
    relation_close(rel, AccessShareLock);
    return events;
}

References AccessShareLock, adjust_view_column_set(), ALL_EVENTS, Assert, bms_int_members(), bms_is_empty, check_stack_depth(), CMD_DELETE, CMD_INSERT, CMD_UPDATE, RewriteRule::event, FdwRoutine::ExecForeignDelete, FdwRoutine::ExecForeignInsert, FdwRoutine::ExecForeignUpdate, FromExpr::fromlist, get_view_query(), GetFdwRoutineForRelation(), i, FdwRoutine::IsForeignRelUpdatable, RewriteRule::isInstead, Query::jointree, lappend_oid(), linitial, list_delete_last(), list_member_oid(), RuleLock::numLocks, RewriteRule::qual, RelationData::rd_rel, RelationData::rd_rules, relation_close(), RelationGetRelid, RangeTblEntry::relid, rt_fetch, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, RangeTblRef::rtindex, RuleLock::rules, Query::targetList, TriggerDesc::trig_delete_instead_row, TriggerDesc::trig_insert_instead_row, TriggerDesc::trig_update_instead_row, RelationData::trigdesc, try_relation_open(), view_cols_are_auto_updatable(), and view_query_is_auto_updatable().

Referenced by pg_column_is_updatable(), and pg_relation_is_updatable().

view_has_instead_trigger()

bool view_has_instead_trigger	(	Relation	view,
		CmdType	event,
		List *	mergeActionList
	)

Definition at line 2469 of file rewriteHandler.c.

{
    TriggerDesc *trigDesc = view->trigdesc;
 
    switch (event)
    {
        case CMD_INSERT:
            if (trigDesc && trigDesc->trig_insert_instead_row)
                return true;
            break;
        case CMD_UPDATE:
            if (trigDesc && trigDesc->trig_update_instead_row)
                return true;
            break;
        case CMD_DELETE:
            if (trigDesc && trigDesc->trig_delete_instead_row)
                return true;
            break;
        case CMD_MERGE:
            foreach_node(MergeAction, action, mergeActionList)
            {
                switch (action->commandType)
                {
                    case CMD_INSERT:
                        if (!trigDesc || !trigDesc->trig_insert_instead_row)
                            return false;
                        break;
                    case CMD_UPDATE:
                        if (!trigDesc || !trigDesc->trig_update_instead_row)
                            return false;
                        break;
                    case CMD_DELETE:
                        if (!trigDesc || !trigDesc->trig_delete_instead_row)
                            return false;
                        break;
                    case CMD_NOTHING:
                        /* No trigger required */
                        break;
                    default:
                        elog(ERROR, "unrecognized commandType: %d", action->commandType);
                        break;
                }
            }
            return true;        /* no actions without an INSTEAD OF trigger */
        default:
            elog(ERROR, "unrecognized CmdType: %d", (int) event);
            break;
    }
    return false;
}

References generate_unaccent_rules::action, CMD_DELETE, CMD_INSERT, CMD_MERGE, CMD_NOTHING, CMD_UPDATE, elog, ERROR, foreach_node, TriggerDesc::trig_delete_instead_row, TriggerDesc::trig_insert_instead_row, TriggerDesc::trig_update_instead_row, and RelationData::trigdesc.

Referenced by CheckValidResultRel(), RewriteQuery(), rewriteTargetView(), and rewriteValuesRTE().

view_query_is_auto_updatable()

const char* view_query_is_auto_updatable	(	Query *	viewquery,
		bool	check_cols
	)

Definition at line 2581 of file rewriteHandler.c.

{
    RangeTblRef *rtr;
    RangeTblEntry *base_rte;
 
    /*----------
     * Check if the view is simply updatable.  According to SQL-92 this means:
     *  - No DISTINCT clause.
     *  - Each TLE is a column reference, and each column appears at most once.
     *  - FROM contains exactly one base relation.
     *  - No GROUP BY or HAVING clauses.
     *  - No set operations (UNION, INTERSECT or EXCEPT).
     *  - No sub-queries in the WHERE clause that reference the target table.
     *
     * We ignore that last restriction since it would be complex to enforce
     * and there isn't any actual benefit to disallowing sub-queries.  (The
     * semantic issues that the standard is presumably concerned about don't
     * arise in Postgres, since any such sub-query will not see any updates
     * executed by the outer query anyway, thanks to MVCC snapshotting.)
     *
     * We also relax the second restriction by supporting part of SQL:1999
     * feature T111, which allows for a mix of updatable and non-updatable
     * columns, provided that an INSERT or UPDATE doesn't attempt to assign to
     * a non-updatable column.
     *
     * In addition we impose these constraints, involving features that are
     * not part of SQL-92:
     *  - No CTEs (WITH clauses).
     *  - No OFFSET or LIMIT clauses (this matches a SQL:2008 restriction).
     *  - No system columns (including whole-row references) in the tlist.
     *  - No window functions in the tlist.
     *  - No set-returning functions in the tlist.
     *
     * Note that we do these checks without recursively expanding the view.
     * If the base relation is a view, we'll recursively deal with it later.
     *----------
     */
    if (viewquery->distinctClause != NIL)
        return gettext_noop("Views containing DISTINCT are not automatically updatable.");
 
    if (viewquery->groupClause != NIL || viewquery->groupingSets)
        return gettext_noop("Views containing GROUP BY are not automatically updatable.");
 
    if (viewquery->havingQual != NULL)
        return gettext_noop("Views containing HAVING are not automatically updatable.");
 
    if (viewquery->setOperations != NULL)
        return gettext_noop("Views containing UNION, INTERSECT, or EXCEPT are not automatically updatable.");
 
    if (viewquery->cteList != NIL)
        return gettext_noop("Views containing WITH are not automatically updatable.");
 
    if (viewquery->limitOffset != NULL || viewquery->limitCount != NULL)
        return gettext_noop("Views containing LIMIT or OFFSET are not automatically updatable.");
 
    /*
     * We must not allow window functions or set returning functions in the
     * targetlist. Otherwise we might end up inserting them into the quals of
     * the main query. We must also check for aggregates in the targetlist in
     * case they appear without a GROUP BY.
     *
     * These restrictions ensure that each row of the view corresponds to a
     * unique row in the underlying base relation.
     */
    if (viewquery->hasAggs)
        return gettext_noop("Views that return aggregate functions are not automatically updatable.");
 
    if (viewquery->hasWindowFuncs)
        return gettext_noop("Views that return window functions are not automatically updatable.");
 
    if (viewquery->hasTargetSRFs)
        return gettext_noop("Views that return set-returning functions are not automatically updatable.");
 
    /*
     * The view query should select from a single base relation, which must be
     * a table or another view.
     */
    if (list_length(viewquery->jointree->fromlist) != 1)
        return gettext_noop("Views that do not select from a single table or view are not automatically updatable.");
 
    rtr = (RangeTblRef *) linitial(viewquery->jointree->fromlist);
    if (!IsA(rtr, RangeTblRef))
        return gettext_noop("Views that do not select from a single table or view are not automatically updatable.");
 
    base_rte = rt_fetch(rtr->rtindex, viewquery->rtable);
    if (base_rte->rtekind != RTE_RELATION ||
        (base_rte->relkind != RELKIND_RELATION &&
         base_rte->relkind != RELKIND_FOREIGN_TABLE &&
         base_rte->relkind != RELKIND_VIEW &&
         base_rte->relkind != RELKIND_PARTITIONED_TABLE))
        return gettext_noop("Views that do not select from a single table or view are not automatically updatable.");
 
    if (base_rte->tablesample)
        return gettext_noop("Views containing TABLESAMPLE are not automatically updatable.");
 
    /*
     * Check that the view has at least one updatable column. This is required
     * for INSERT/UPDATE but not for DELETE.
     */
    if (check_cols)
    {
        ListCell   *cell;
        bool        found;
 
        found = false;
        foreach(cell, viewquery->targetList)
        {
            TargetEntry *tle = (TargetEntry *) lfirst(cell);
 
            if (view_col_is_auto_updatable(rtr, tle) == NULL)
            {
                found = true;
                break;
            }
        }
 
        if (!found)
            return gettext_noop("Views that have no updatable columns are not automatically updatable.");
    }
 
    return NULL;                /* the view is updatable */
}

References Query::cteList, Query::distinctClause, FromExpr::fromlist, gettext_noop, Query::groupClause, Query::groupingSets, Query::havingQual, IsA, Query::jointree, lfirst, Query::limitCount, Query::limitOffset, linitial, list_length(), NIL, rt_fetch, Query::rtable, RTE_RELATION, RangeTblEntry::rtekind, RangeTblRef::rtindex, Query::setOperations, RangeTblEntry::tablesample, Query::targetList, and view_col_is_auto_updatable().

Referenced by ATExecSetRelOptions(), DefineView(), relation_is_updatable(), and rewriteTargetView().