view.h File Reference

#include "catalog/objectaddress.h"
#include "nodes/parsenodes.h"

Include dependency graph for view.h:

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

Go to the source code of this file.

Functions
void	validateWithCheckOption (const char *value)
ObjectAddress	DefineView (ViewStmt *stmt, const char *queryString, int stmt_location, int stmt_len)
void	StoreViewQuery (Oid viewOid, Query *viewParse, bool replace)

Function Documentation

DefineView()

ObjectAddress DefineView	(	ViewStmt *	stmt,
		const char *	queryString,
		int	stmt_location,
		int	stmt_len
	)

Definition at line 417 of file view.c.

References ViewStmt::aliases, CASCADED_CHECK_OPTION, CMD_SELECT, Query::commandType, copyObject, DefineVirtualRelation(), DefElem::defname, elog, ereport, errcode(), errhint(), errmsg(), ERROR, Query::hasModifyingCTE, IsA, isQueryUsingTempRelation(), lappend(), lfirst, lfirst_node, list_head(), lnext, LOCAL_CHECK_OPTION, makeDefElem(), makeNode, makeString(), NIL, NOTICE, ViewStmt::options, parse_analyze(), pstrdup(), ViewStmt::query, RangeVar::relname, RangeVar::relpersistence, ViewStmt::replace, TargetEntry::resjunk, TargetEntry::resname, RawStmt::stmt, RawStmt::stmt_len, RawStmt::stmt_location, strVal, Query::targetList, Query::utilityStmt, ViewStmt::view, view_query_is_auto_updatable(), and ViewStmt::withCheckOption.

Referenced by ProcessUtilitySlow().

{
    RawStmt    *rawstmt;
    Query      *viewParse;
    RangeVar   *view;
    ListCell   *cell;
    bool        check_option;
    ObjectAddress address;

    /*
     * Run parse analysis to convert the raw parse tree to a Query.  Note this
     * also acquires sufficient locks on the source table(s).
     *
     * Since parse analysis scribbles on its input, copy the raw parse tree;
     * this ensures we don't corrupt a prepared statement, for example.
     */
    rawstmt = makeNode(RawStmt);
    rawstmt->stmt = (Node *) copyObject(stmt->query);
    rawstmt->stmt_location = stmt_location;
    rawstmt->stmt_len = stmt_len;

    viewParse = parse_analyze(rawstmt, queryString, NULL, 0, NULL);

    /*
     * The grammar should ensure that the result is a single SELECT Query.
     * However, it doesn't forbid SELECT INTO, so we have to check for that.
     */
    if (!IsA(viewParse, Query))
        elog(ERROR, "unexpected parse analysis result");
    if (viewParse->utilityStmt != NULL &&
        IsA(viewParse->utilityStmt, CreateTableAsStmt))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("views must not contain SELECT INTO")));
    if (viewParse->commandType != CMD_SELECT)
        elog(ERROR, "unexpected parse analysis result");

    /*
     * Check for unsupported cases.  These tests are redundant with ones in
     * DefineQueryRewrite(), but that function will complain about a bogus ON
     * SELECT rule, and we'd rather the message complain about a view.
     */
    if (viewParse->hasModifyingCTE)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("views must not contain data-modifying statements in WITH")));

    /*
     * If the user specified the WITH CHECK OPTION, add it to the list of
     * reloptions.
     */
    if (stmt->withCheckOption == LOCAL_CHECK_OPTION)
        stmt->options = lappend(stmt->options,
                                makeDefElem("check_option",
                                            (Node *) makeString("local"), -1));
    else if (stmt->withCheckOption == CASCADED_CHECK_OPTION)
        stmt->options = lappend(stmt->options,
                                makeDefElem("check_option",
                                            (Node *) makeString("cascaded"), -1));

    /*
     * Check that the view is auto-updatable if WITH CHECK OPTION was
     * specified.
     */
    check_option = false;

    foreach(cell, stmt->options)
    {
        DefElem    *defel = (DefElem *) lfirst(cell);

        if (strcmp(defel->defname, "check_option") == 0)
            check_option = true;
    }

    /*
     * If the check option is specified, look to see if the view is actually
     * auto-updatable or not.
     */
    if (check_option)
    {
        const char *view_updatable_error =
        view_query_is_auto_updatable(viewParse, true);

        if (view_updatable_error)
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("WITH CHECK OPTION is supported only on automatically updatable views"),
                     errhint("%s", view_updatable_error)));
    }

    /*
     * If a list of column names was given, run through and insert these into
     * the actual query tree. - thomas 2000-03-08
     */
    if (stmt->aliases != NIL)
    {
        ListCell   *alist_item = list_head(stmt->aliases);
        ListCell   *targetList;

        foreach(targetList, viewParse->targetList)
        {
            TargetEntry *te = lfirst_node(TargetEntry, targetList);

            /* junk columns don't get aliases */
            if (te->resjunk)
                continue;
            te->resname = pstrdup(strVal(lfirst(alist_item)));
            alist_item = lnext(alist_item);
            if (alist_item == NULL)
                break;          /* done assigning aliases */
        }

        if (alist_item != NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("CREATE VIEW specifies more column "
                            "names than columns")));
    }

    /* Unlogged views are not sensible. */
    if (stmt->view->relpersistence == RELPERSISTENCE_UNLOGGED)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("views cannot be unlogged because they do not have storage")));

    /*
     * If the user didn't explicitly ask for a temporary view, check whether
     * we need one implicitly.  We allow TEMP to be inserted automatically as
     * long as the CREATE command is consistent with that --- no explicit
     * schema name.
     */
    view = copyObject(stmt->view);  /* don't corrupt original command */
    if (view->relpersistence == RELPERSISTENCE_PERMANENT
        && isQueryUsingTempRelation(viewParse))
    {
        view->relpersistence = RELPERSISTENCE_TEMP;
        ereport(NOTICE,
                (errmsg("view \"%s\" will be a temporary view",
                        view->relname)));
    }

    /*
     * Create the view relation
     *
     * NOTE: if it already exists and replace is false, the xact will be
     * aborted.
     */
    address = DefineVirtualRelation(view, viewParse->targetList,
                                    stmt->replace, stmt->options, viewParse);

    return address;
}

StoreViewQuery()

void StoreViewQuery	(	Oid	viewOid,
		Query *	viewParse,
		bool	replace
	)

Definition at line 575 of file view.c.

References DefineViewRules(), and UpdateRangeTableOfViewParse().

Referenced by create_ctas_internal(), and DefineVirtualRelation().

{
    /*
     * The range table of 'viewParse' does not contain entries for the "OLD"
     * and "NEW" relations. So... add them!
     */
    viewParse = UpdateRangeTableOfViewParse(viewOid, viewParse);

    /*
     * Now create the rules associated with the view.
     */
    DefineViewRules(viewOid, viewParse, replace);
}

validateWithCheckOption()

void validateWithCheckOption

(

const char *

value

)

Definition at line 46 of file view.c.

References ereport, errcode(), errdetail(), errmsg(), and ERROR.

{
    if (value == NULL ||
        (strcmp(value, "local") != 0 &&
         strcmp(value, "cascaded") != 0))
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid value for \"check_option\" option"),
                 errdetail("Valid values are \"local\" and \"cascaded\".")));
    }
}