matview.h File Reference

#include "catalog/objectaddress.h"
#include "nodes/params.h"
#include "nodes/parsenodes.h"
#include "tcop/dest.h"
#include "utils/relcache.h"

Include dependency graph for matview.h:

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

Go to the source code of this file.

Functions
void	SetMatViewPopulatedState (Relation relation, bool newstate)
ObjectAddress	ExecRefreshMatView (RefreshMatViewStmt *stmt, const char *queryString, QueryCompletion *qc)
ObjectAddress	RefreshMatViewByOid (Oid matviewOid, bool is_create, bool skipData, bool concurrent, const char *queryString, QueryCompletion *qc)
DestReceiver *	CreateTransientRelDestReceiver (Oid transientoid)
bool	MatViewIncrementalMaintenanceIsEnabled (void)

Function Documentation

CreateTransientRelDestReceiver()

DestReceiver * CreateTransientRelDestReceiver

(

Oid

transientoid

)

Definition at line 466 of file matview.c.

{
    DR_transientrel *self = (DR_transientrel *) palloc0(sizeof(DR_transientrel));
 
    self->pub.receiveSlot = transientrel_receive;
    self->pub.rStartup = transientrel_startup;
    self->pub.rShutdown = transientrel_shutdown;
    self->pub.rDestroy = transientrel_destroy;
    self->pub.mydest = DestTransientRel;
    self->transientoid = transientoid;
 
    return (DestReceiver *) self;
}

References DestTransientRel, _DestReceiver::mydest, palloc0(), DR_transientrel::pub, _DestReceiver::rDestroy, _DestReceiver::receiveSlot, _DestReceiver::rShutdown, _DestReceiver::rStartup, DR_transientrel::transientoid, transientrel_destroy(), transientrel_receive(), transientrel_shutdown(), and transientrel_startup().

Referenced by CreateDestReceiver(), and RefreshMatViewByOid().

ExecRefreshMatView()

ObjectAddress ExecRefreshMatView	(	RefreshMatViewStmt *	stmt,
		const char *	queryString,
		QueryCompletion *	qc
	)

Definition at line 121 of file matview.c.

{
    Oid         matviewOid;
    LOCKMODE    lockmode;
 
    /* Determine strength of lock needed. */
    lockmode = stmt->concurrent ? ExclusiveLock : AccessExclusiveLock;
 
    /*
     * Get a lock until end of transaction.
     */
    matviewOid = RangeVarGetRelidExtended(stmt->relation,
                                          lockmode, 0,
                                          RangeVarCallbackMaintainsTable,
                                          NULL);
 
    return RefreshMatViewByOid(matviewOid, false, stmt->skipData,
                               stmt->concurrent, queryString, qc);
}

References AccessExclusiveLock, ExclusiveLock, RangeVarCallbackMaintainsTable(), RangeVarGetRelidExtended(), RefreshMatViewByOid(), and stmt.

Referenced by ProcessUtilitySlow().

MatViewIncrementalMaintenanceIsEnabled()

bool MatViewIncrementalMaintenanceIsEnabled

(

void

)

Definition at line 964 of file matview.c.

{
    return matview_maintenance_depth > 0;
}

References matview_maintenance_depth.

Referenced by CheckValidResultRel().

RefreshMatViewByOid()

ObjectAddress RefreshMatViewByOid	(	Oid	matviewOid,
		bool	is_create,
		bool	skipData,
		bool	concurrent,
		const char *	queryString,
		QueryCompletion *	qc
	)

Definition at line 165 of file matview.c.

{
    Relation    matviewRel;
    RewriteRule *rule;
    List       *actions;
    Query      *dataQuery;
    Oid         tableSpace;
    Oid         relowner;
    Oid         OIDNewHeap;
    uint64      processed = 0;
    char        relpersistence;
    Oid         save_userid;
    int         save_sec_context;
    int         save_nestlevel;
    ObjectAddress address;
 
    matviewRel = table_open(matviewOid, NoLock);
    relowner = matviewRel->rd_rel->relowner;
 
    /*
     * Switch to the owner's userid, so that any functions are run as that
     * user.  Also lock down security-restricted operations and arrange to
     * make GUC variable changes local to this command.
     */
    GetUserIdAndSecContext(&save_userid, &save_sec_context);
    SetUserIdAndSecContext(relowner,
                           save_sec_context | SECURITY_RESTRICTED_OPERATION);
    save_nestlevel = NewGUCNestLevel();
    RestrictSearchPath();
 
    /* Make sure it is a materialized view. */
    if (matviewRel->rd_rel->relkind != RELKIND_MATVIEW)
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("\"%s\" is not a materialized view",
                        RelationGetRelationName(matviewRel))));
 
    /* Check that CONCURRENTLY is not specified if not populated. */
    if (concurrent && !RelationIsPopulated(matviewRel))
        ereport(ERROR,
                (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                 errmsg("CONCURRENTLY cannot be used when the materialized view is not populated")));
 
    /* Check that conflicting options have not been specified. */
    if (concurrent && skipData)
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("%s and %s options cannot be used together",
                        "CONCURRENTLY", "WITH NO DATA")));
 
    /*
     * Check that everything is correct for a refresh. Problems at this point
     * are internal errors, so elog is sufficient.
     */
    if (matviewRel->rd_rel->relhasrules == false ||
        matviewRel->rd_rules->numLocks < 1)
        elog(ERROR,
             "materialized view \"%s\" is missing rewrite information",
             RelationGetRelationName(matviewRel));
 
    if (matviewRel->rd_rules->numLocks > 1)
        elog(ERROR,
             "materialized view \"%s\" has too many rules",
             RelationGetRelationName(matviewRel));
 
    rule = matviewRel->rd_rules->rules[0];
    if (rule->event != CMD_SELECT || !(rule->isInstead))
        elog(ERROR,
             "the rule for materialized view \"%s\" is not a SELECT INSTEAD OF rule",
             RelationGetRelationName(matviewRel));
 
    actions = rule->actions;
    if (list_length(actions) != 1)
        elog(ERROR,
             "the rule for materialized view \"%s\" is not a single action",
             RelationGetRelationName(matviewRel));
 
    /*
     * Check that there is a unique index with no WHERE clause on one or more
     * columns of the materialized view if CONCURRENTLY is specified.
     */
    if (concurrent)
    {
        List       *indexoidlist = RelationGetIndexList(matviewRel);
        ListCell   *indexoidscan;
        bool        hasUniqueIndex = false;
 
        Assert(!is_create);
 
        foreach(indexoidscan, indexoidlist)
        {
            Oid         indexoid = lfirst_oid(indexoidscan);
            Relation    indexRel;
 
            indexRel = index_open(indexoid, AccessShareLock);
            hasUniqueIndex = is_usable_unique_index(indexRel);
            index_close(indexRel, AccessShareLock);
            if (hasUniqueIndex)
                break;
        }
 
        list_free(indexoidlist);
 
        if (!hasUniqueIndex)
            ereport(ERROR,
                    (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
                     errmsg("cannot refresh materialized view \"%s\" concurrently",
                            quote_qualified_identifier(get_namespace_name(RelationGetNamespace(matviewRel)),
                                                       RelationGetRelationName(matviewRel))),
                     errhint("Create a unique index with no WHERE clause on one or more columns of the materialized view.")));
    }
 
    /*
     * The stored query was rewritten at the time of the MV definition, but
     * has not been scribbled on by the planner.
     */
    dataQuery = linitial_node(Query, actions);
 
    /*
     * Check for active uses of the relation in the current transaction, such
     * as open scans.
     *
     * NB: We count on this to protect us against problems with refreshing the
     * data using TABLE_INSERT_FROZEN.
     */
    CheckTableNotInUse(matviewRel,
                       is_create ? "CREATE MATERIALIZED VIEW" :
                       "REFRESH MATERIALIZED VIEW");
 
    /*
     * Tentatively mark the matview as populated or not (this will roll back
     * if we fail later).
     */
    SetMatViewPopulatedState(matviewRel, !skipData);
 
    /* Concurrent refresh builds new data in temp tablespace, and does diff. */
    if (concurrent)
    {
        tableSpace = GetDefaultTablespace(RELPERSISTENCE_TEMP, false);
        relpersistence = RELPERSISTENCE_TEMP;
    }
    else
    {
        tableSpace = matviewRel->rd_rel->reltablespace;
        relpersistence = matviewRel->rd_rel->relpersistence;
    }
 
    /*
     * Create the transient table that will receive the regenerated data. Lock
     * it against access by any other process until commit (by which time it
     * will be gone).
     */
    OIDNewHeap = make_new_heap(matviewOid, tableSpace,
                               matviewRel->rd_rel->relam,
                               relpersistence, ExclusiveLock);
    Assert(CheckRelationOidLockedByMe(OIDNewHeap, AccessExclusiveLock, false));
 
    /* Generate the data, if wanted. */
    if (!skipData)
    {
        DestReceiver *dest;
 
        dest = CreateTransientRelDestReceiver(OIDNewHeap);
        processed = refresh_matview_datafill(dest, dataQuery, queryString,
                                             is_create);
    }
 
    /* Make the matview match the newly generated data. */
    if (concurrent)
    {
        int         old_depth = matview_maintenance_depth;
 
        PG_TRY();
        {
            refresh_by_match_merge(matviewOid, OIDNewHeap, relowner,
                                   save_sec_context);
        }
        PG_CATCH();
        {
            matview_maintenance_depth = old_depth;
            PG_RE_THROW();
        }
        PG_END_TRY();
        Assert(matview_maintenance_depth == old_depth);
    }
    else
    {
        refresh_by_heap_swap(matviewOid, OIDNewHeap, relpersistence);
 
        /*
         * Inform cumulative stats system about our activity: basically, we
         * truncated the matview and inserted some new data.  (The concurrent
         * code path above doesn't need to worry about this because the
         * inserts and deletes it issues get counted by lower-level code.)
         */
        pgstat_count_truncate(matviewRel);
        if (!skipData)
            pgstat_count_heap_insert(matviewRel, processed);
    }
 
    table_close(matviewRel, NoLock);
 
    /* Roll back any GUC changes */
    AtEOXact_GUC(false, save_nestlevel);
 
    /* Restore userid and security context */
    SetUserIdAndSecContext(save_userid, save_sec_context);
 
    ObjectAddressSet(address, RelationRelationId, matviewOid);
 
    /*
     * Save the rowcount so that pg_stat_statements can track the total number
     * of rows processed by REFRESH MATERIALIZED VIEW command. Note that we
     * still don't display the rowcount in the command completion tag output,
     * i.e., the display_rowcount flag of CMDTAG_REFRESH_MATERIALIZED_VIEW
     * command tag is left false in cmdtaglist.h. Otherwise, the change of
     * completion tag output might break applications using it.
     *
     * When called from CREATE MATERIALIZED VIEW command, the rowcount is
     * displayed with the command tag CMDTAG_SELECT.
     */
    if (qc)
        SetQueryCompletion(qc,
                           is_create ? CMDTAG_SELECT : CMDTAG_REFRESH_MATERIALIZED_VIEW,
                           processed);
 
    return address;
}

References AccessExclusiveLock, AccessShareLock, Assert(), AtEOXact_GUC(), CheckRelationOidLockedByMe(), CheckTableNotInUse(), CMD_SELECT, CreateTransientRelDestReceiver(), generate_unaccent_rules::dest, elog, ereport, errcode(), errhint(), errmsg(), ERROR, ExclusiveLock, get_namespace_name(), GetDefaultTablespace(), GetUserIdAndSecContext(), index_close(), index_open(), is_usable_unique_index(), lfirst_oid, linitial_node, list_free(), list_length(), make_new_heap(), matview_maintenance_depth, NewGUCNestLevel(), NoLock, RuleLock::numLocks, ObjectAddressSet, PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, pgstat_count_heap_insert(), pgstat_count_truncate(), quote_qualified_identifier(), RelationData::rd_rel, RelationData::rd_rules, refresh_by_heap_swap(), refresh_by_match_merge(), refresh_matview_datafill(), RelationGetIndexList(), RelationGetNamespace, RelationGetRelationName, RelationIsPopulated, RestrictSearchPath(), RuleLock::rules, SECURITY_RESTRICTED_OPERATION, SetMatViewPopulatedState(), SetQueryCompletion(), SetUserIdAndSecContext(), table_close(), and table_open().

Referenced by ExecCreateTableAs(), and ExecRefreshMatView().

SetMatViewPopulatedState()

void SetMatViewPopulatedState	(	Relation	relation,
		bool	newstate
	)

Definition at line 79 of file matview.c.

{
    Relation    pgrel;
    HeapTuple   tuple;
 
    Assert(relation->rd_rel->relkind == RELKIND_MATVIEW);
 
    /*
     * Update relation's pg_class entry.  Crucial side-effect: other backends
     * (and this one too!) are sent SI message to make them rebuild relcache
     * entries.
     */
    pgrel = table_open(RelationRelationId, RowExclusiveLock);
    tuple = SearchSysCacheCopy1(RELOID,
                                ObjectIdGetDatum(RelationGetRelid(relation)));
    if (!HeapTupleIsValid(tuple))
        elog(ERROR, "cache lookup failed for relation %u",
             RelationGetRelid(relation));
 
    ((Form_pg_class) GETSTRUCT(tuple))->relispopulated = newstate;
 
    CatalogTupleUpdate(pgrel, &tuple->t_self, tuple);
 
    heap_freetuple(tuple);
    table_close(pgrel, RowExclusiveLock);
 
    /*
     * Advance command counter to make the updated pg_class row locally
     * visible.
     */
    CommandCounterIncrement();
}

References Assert(), CatalogTupleUpdate(), CommandCounterIncrement(), elog, ERROR, GETSTRUCT(), heap_freetuple(), HeapTupleIsValid, newstate(), ObjectIdGetDatum(), RelationData::rd_rel, RelationGetRelid, RowExclusiveLock, SearchSysCacheCopy1, HeapTupleData::t_self, table_close(), and table_open().

Referenced by intorel_startup(), and RefreshMatViewByOid().