#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 465 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, palloc0(), 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 970 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);
     LockRelationOid(OIDNewHeap, AccessExclusiveLock);
  
     /* 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(), 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(), LockRelationOid(), 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().