/*-------------------------------------------------------------------------

 *

 * matview.c

 *    materialized view support

 *

 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group

 * Portions Copyright (c) 1994, Regents of the University of California

 *

 *

 * IDENTIFICATION

 *    src/backend/commands/matview.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "access/genam.h"

#include "access/heapam.h"

#include "access/htup_details.h"

#include "access/multixact.h"

#include "access/tableam.h"

#include "access/xact.h"

#include "catalog/indexing.h"

#include "catalog/namespace.h"

#include "catalog/pg_am.h"

#include "catalog/pg_opclass.h"

#include "commands/matview.h"

#include "commands/repack.h"

#include "commands/tablecmds.h"

#include "commands/tablespace.h"

#include "executor/executor.h"

#include "executor/spi.h"

#include "miscadmin.h"

#include "pgstat.h"

#include "rewrite/rewriteHandler.h"

#include "storage/lmgr.h"

#include "tcop/tcopprot.h"

#include "utils/builtins.h"

#include "utils/lsyscache.h"

#include "utils/rel.h"

#include "utils/snapmgr.h"

#include "utils/syscache.h"

typedef struct

{

  DestReceiver pub;     /* publicly-known function pointers */

  Oid     transientoid; /* OID of new heap into which to store */

  /* These fields are filled by transientrel_startup: */

  Relation  transientrel; /* relation to write to */

  CommandId output_cid;   /* cmin to insert in output tuples */

  uint32    ti_options;   /* table_tuple_insert performance options */

  BulkInsertState bistate;  /* bulk insert state */

} DR_transientrel;

static int  matview_maintenance_depth = 0;

static void transientrel_startup(DestReceiver *self, int operation, TupleDesc typeinfo);

static bool transientrel_receive(TupleTableSlot *slot, DestReceiver *self);

static void transientrel_shutdown(DestReceiver *self);

static void transientrel_destroy(DestReceiver *self);

static uint64 refresh_matview_datafill(DestReceiver *dest, Query *query,

                     const char *queryString, bool is_create);

static void refresh_by_match_merge(Oid matviewOid, Oid tempOid, Oid relowner,

                   int save_sec_context);

static void refresh_by_heap_swap(Oid matviewOid, Oid OIDNewHeap, char relpersistence);

static bool is_usable_unique_index(Relation indexRel);

static void OpenMatViewIncrementalMaintenance(void);

static void CloseMatViewIncrementalMaintenance(void);

/*

 * SetMatViewPopulatedState

 *    Mark a materialized view as populated, or not.

 *

 * NOTE: caller must be holding an appropriate lock on the relation.

 */

void

SetMatViewPopulatedState(Relation relation, bool newstate)

{

  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();

}

/*

 * ExecRefreshMatView -- execute a REFRESH MATERIALIZED VIEW command

 *

 * If WITH NO DATA was specified, this is effectively like a TRUNCATE;

 * otherwise it is like a TRUNCATE followed by an INSERT using the SELECT

 * statement associated with the materialized view.  The statement node's

 * skipData field shows whether the clause was used.

 */

ObjectAddress

ExecRefreshMatView(RefreshMatViewStmt *stmt, const char *queryString,

           QueryCompletion *qc)

{

  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);

}

/*

 * RefreshMatViewByOid -- refresh materialized view by OID

 *

 * This refreshes the materialized view by creating a new table and swapping

 * the relfilenumbers of the new table and the old materialized view, so the OID

 * of the original materialized view is preserved. Thus we do not lose GRANT

 * nor references to this materialized view.

 *

 * If skipData is true, this is effectively like a TRUNCATE; otherwise it is

 * like a TRUNCATE followed by an INSERT using the SELECT statement associated

 * with the materialized view.

 *

 * Indexes are rebuilt too, via REINDEX. Since we are effectively bulk-loading

 * the new heap, it's better to create the indexes afterwards than to fill them

 * incrementally while we load.

 *

 * The matview's "populated" state is changed based on whether the contents

 * reflect the result set of the materialized view's query.

 *

 * This is also used to populate the materialized view created by CREATE

 * MATERIALIZED VIEW command.

 */

ObjectAddress

RefreshMatViewByOid(Oid matviewOid, bool is_create, bool skipData,

          bool concurrent, const char *queryString,

          QueryCompletion *qc)

{

  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 options %s and %s cannot be used together",

            "REFRESH", "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, if its state is

   * changing (this will roll back if we fail later).

   */

  if (RelationIsPopulated(matviewRel) != !skipData)

    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;

}

/*

 * refresh_matview_datafill

 *

 * Execute the given query, sending result rows to "dest" (which will

 * insert them into the target matview).

 *

 * Returns number of rows inserted.

 */

static uint64

refresh_matview_datafill(DestReceiver *dest, Query *query,

             const char *queryString, bool is_create)

{

  List     *rewritten;

  PlannedStmt *plan;

  QueryDesc  *queryDesc;

  Query    *copied_query;

  uint64    processed;

  /* Lock and rewrite, using a copy to preserve the original query. */

  copied_query = copyObject(query);

  AcquireRewriteLocks(copied_query, true, false);

  rewritten = QueryRewrite(copied_query);

  /* SELECT should never rewrite to more or less than one SELECT query */

  if (list_length(rewritten) != 1)

    elog(ERROR, "unexpected rewrite result for %s",

       is_create ? "CREATE MATERIALIZED VIEW " : "REFRESH MATERIALIZED VIEW");

  query = (Query *) linitial(rewritten);

  /* Check for user-requested abort. */

  CHECK_FOR_INTERRUPTS();

  /* Plan the query which will generate data for the refresh. */

  plan = pg_plan_query(query, queryString, CURSOR_OPT_PARALLEL_OK, NULL, NULL);

  /*

   * Use a snapshot with an updated command ID to ensure this query sees

   * results of any previously executed queries.  (This could only matter if

   * the planner executed an allegedly-stable function that changed the

   * database contents, but let's do it anyway to be safe.)

   */

  PushCopiedSnapshot(GetActiveSnapshot());

  UpdateActiveSnapshotCommandId();

  /* Create a QueryDesc, redirecting output to our tuple receiver */

  queryDesc = CreateQueryDesc(plan, queryString,

                GetActiveSnapshot(), InvalidSnapshot,

                dest, NULL, NULL, 0);

  /* call ExecutorStart to prepare the plan for execution */

  ExecutorStart(queryDesc, 0);

  /* run the plan */

  ExecutorRun(queryDesc, ForwardScanDirection, 0);

  processed = queryDesc->estate->es_processed;

  /* and clean up */

  ExecutorFinish(queryDesc);

  ExecutorEnd(queryDesc);

  FreeQueryDesc(queryDesc);

  PopActiveSnapshot();

  return processed;

}

DestReceiver *

CreateTransientRelDestReceiver(Oid transientoid)

{

  DR_transientrel *self = palloc0_object(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;

}

/*

 * transientrel_startup --- executor startup

 */

static void

transientrel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)

{

  DR_transientrel *myState = (DR_transientrel *) self;

  Relation  transientrel;

  transientrel = table_open(myState->transientoid, NoLock);

  /*

   * Fill private fields of myState for use by later routines

   */

  myState->transientrel = transientrel;

  myState->output_cid = GetCurrentCommandId(true);

  myState->ti_options = TABLE_INSERT_SKIP_FSM | TABLE_INSERT_FROZEN;

  myState->bistate = GetBulkInsertState();

  /*

   * Valid smgr_targblock implies something already wrote to the relation.

   * This may be harmless, but this function hasn't planned for it.

   */

  Assert(RelationGetTargetBlock(transientrel) == InvalidBlockNumber);

}

/*

 * transientrel_receive --- receive one tuple

 */

static bool

transientrel_receive(TupleTableSlot *slot, DestReceiver *self)

{

  DR_transientrel *myState = (DR_transientrel *) self;

  /*

   * Note that the input slot might not be of the type of the target

   * relation. That's supported by table_tuple_insert(), but slightly less

   * efficient than inserting with the right slot - but the alternative

   * would be to copy into a slot of the right type, which would not be

   * cheap either. This also doesn't allow accessing per-AM data (say a

   * tuple's xmin), but since we don't do that here...

   */

  table_tuple_insert(myState->transientrel,

             slot,

             myState->output_cid,

             myState->ti_options,

             myState->bistate);

  /* We know this is a newly created relation, so there are no indexes */

  return true;

}

/*

 * transientrel_shutdown --- executor end

 */

static void

transientrel_shutdown(DestReceiver *self)

{

  DR_transientrel *myState = (DR_transientrel *) self;

  FreeBulkInsertState(myState->bistate);

  table_finish_bulk_insert(myState->transientrel, myState->ti_options);

  /* close transientrel, but keep lock until commit */

  table_close(myState->transientrel, NoLock);

  myState->transientrel = NULL;

}

/*

 * transientrel_destroy --- release DestReceiver object

 */

static void

transientrel_destroy(DestReceiver *self)

{

  pfree(self);

}

/*

 * refresh_by_match_merge

 *

 * Refresh a materialized view with transactional semantics, while allowing

 * concurrent reads.

 *

 * This is called after a new version of the data has been created in a

 * temporary table.  It performs a full outer join against the old version of

 * the data, producing "diff" results.  This join cannot work if there are any

 * duplicated rows in either the old or new versions, in the sense that every

 * column would compare as equal between the two rows.  It does work correctly

 * in the face of rows which have at least one NULL value, with all non-NULL

 * columns equal.  The behavior of NULLs on equality tests and on UNIQUE

 * indexes turns out to be quite convenient here; the tests we need to make

 * are consistent with default behavior.  If there is at least one UNIQUE

 * index on the materialized view, we have exactly the guarantee we need.

 *

 * The temporary table used to hold the diff results contains just the TID of

 * the old record (if matched) and the ROW from the new table as a single

 * column of complex record type (if matched).

 *

 * Once we have the diff table, we perform set-based DELETE and INSERT

 * operations against the materialized view, and discard both temporary

 * tables.

 *

 * Everything from the generation of the new data to applying the differences

 * takes place under cover of an ExclusiveLock, since it seems as though we

 * would want to prohibit not only concurrent REFRESH operations, but also

 * incremental maintenance.  It also doesn't seem reasonable or safe to allow

 * SELECT FOR UPDATE or SELECT FOR SHARE on rows being updated or deleted by

 * this command.

 */

static void

refresh_by_match_merge(Oid matviewOid, Oid tempOid, Oid relowner,

             int save_sec_context)

{

  StringInfoData querybuf;

  Relation  matviewRel;

  Relation  tempRel;

  char     *matviewname;

  char     *tempname;

  char     *diffname;

  char     *temprelname;

  char     *diffrelname;

  char     *nsp;

  TupleDesc tupdesc;

  bool    foundUniqueIndex;

  List     *indexoidlist;

  ListCell   *indexoidscan;

  int16   relnatts;

  Oid      *opUsedForQual;

  initStringInfo(&querybuf);

  matviewRel = table_open(matviewOid, NoLock);

  matviewname = quote_qualified_identifier(get_namespace_name(RelationGetNamespace(matviewRel)),

                       RelationGetRelationName(matviewRel));

  tempRel = table_open(tempOid, NoLock);

  /*

   * Build qualified names of the temporary table and the diff table.  The

   * only difference between them is the "_2" suffix on the diff table name.

   */

  nsp = get_namespace_name(RelationGetNamespace(tempRel));

  temprelname = RelationGetRelationName(tempRel);

  diffrelname = psprintf("%s_2", temprelname);

  tempname = quote_qualified_identifier(nsp, temprelname);

  diffname = quote_qualified_identifier(nsp, diffrelname);

  relnatts = RelationGetNumberOfAttributes(matviewRel);

  /* Open SPI context. */

  SPI_connect();

  /* Analyze the temp table with the new contents. */

  appendStringInfo(&querybuf, "ANALYZE %s", tempname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_UTILITY)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  /*

   * We need to ensure that there are not duplicate rows without NULLs in

   * the new data set before we can count on the "diff" results.  Check for

   * that in a way that allows showing the first duplicated row found.  Even

   * after we pass this test, a unique index on the materialized view may

   * find a duplicate key problem.

   *

   * Note: here and below, we use "tablename.*::tablerowtype" as a hack to

   * keep ".*" from being expanded into multiple columns in a SELECT list.

   * Compare ruleutils.c's get_variable().

   */

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf,

           "SELECT newdata.*::%s FROM %s newdata "

           "WHERE newdata.* IS NOT NULL AND EXISTS "

           "(SELECT 1 FROM %s newdata2 WHERE newdata2.* IS NOT NULL "

           "AND newdata2.* OPERATOR(pg_catalog.*=) newdata.* "

           "AND newdata2.ctid OPERATOR(pg_catalog.<>) "

           "newdata.ctid)",

           tempname, tempname, tempname);

  if (SPI_execute(querybuf.data, false, 1) != SPI_OK_SELECT)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  if (SPI_processed > 0)

  {

    /*

     * Note that this ereport() is returning data to the user.  Generally,

     * we would want to make sure that the user has been granted access to

     * this data.  However, REFRESH MAT VIEW is only able to be run by the

     * owner of the mat view (or a superuser) and therefore there is no

     * need to check for access to data in the mat view.

     */

    ereport(ERROR,

        (errcode(ERRCODE_CARDINALITY_VIOLATION),

         errmsg("new data for materialized view \"%s\" contains duplicate rows without any null columns",

            RelationGetRelationName(matviewRel)),

         errdetail("Row: %s",

               SPI_getvalue(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1))));

  }

  /*

   * Create the temporary "diff" table.

   *

   * Temporarily switch out of the SECURITY_RESTRICTED_OPERATION context,

   * because you cannot create temp tables in SRO context.  For extra

   * paranoia, add the composite type column only after switching back to

   * SRO context.

   */

  SetUserIdAndSecContext(relowner,

               save_sec_context | SECURITY_LOCAL_USERID_CHANGE);

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf,

           "CREATE TEMP TABLE %s (tid pg_catalog.tid)",

           diffname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_UTILITY)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  SetUserIdAndSecContext(relowner,

               save_sec_context | SECURITY_RESTRICTED_OPERATION);

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf,

           "ALTER TABLE %s ADD COLUMN newdata %s",

           diffname, tempname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_UTILITY)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  /* Start building the query for populating the diff table. */

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf,

           "INSERT INTO %s "

           "SELECT mv.ctid AS tid, newdata.*::%s AS newdata "

           "FROM %s mv FULL JOIN %s newdata ON (",

           diffname, tempname, matviewname, tempname);

  /*

   * Get the list of index OIDs for the table from the relcache, and look up

   * each one in the pg_index syscache.  We will test for equality on all

   * columns present in all unique indexes which only reference columns and

   * include all rows.

   */

  tupdesc = matviewRel->rd_att;

  opUsedForQual = palloc0_array(Oid, relnatts);

  foundUniqueIndex = false;

  indexoidlist = RelationGetIndexList(matviewRel);

  foreach(indexoidscan, indexoidlist)

  {

    Oid     indexoid = lfirst_oid(indexoidscan);

    Relation  indexRel;

    indexRel = index_open(indexoid, RowExclusiveLock);

    if (is_usable_unique_index(indexRel))

    {

      Form_pg_index indexStruct = indexRel->rd_index;

      int     indnkeyatts = indexStruct->indnkeyatts;

      oidvector  *indclass;

      Datum   indclassDatum;

      int     i;

      /* Must get indclass the hard way. */

      indclassDatum = SysCacheGetAttrNotNull(INDEXRELID,

                           indexRel->rd_indextuple,

                           Anum_pg_index_indclass);

      indclass = (oidvector *) DatumGetPointer(indclassDatum);

      /* Add quals for all columns from this index. */

      for (i = 0; i < indnkeyatts; i++)

      {

        int     attnum = indexStruct->indkey.values[i];

        Oid     opclass = indclass->values[i];

        Form_pg_attribute attr = TupleDescAttr(tupdesc, attnum - 1);

        Oid     attrtype = attr->atttypid;

        HeapTuple cla_ht;

        Form_pg_opclass cla_tup;

        Oid     opfamily;

        Oid     opcintype;

        Oid     op;

        const char *leftop;

        const char *rightop;

        /*

         * Identify the equality operator associated with this index

         * column.  First we need to look up the column's opclass.

         */

        cla_ht = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclass));

        if (!HeapTupleIsValid(cla_ht))

          elog(ERROR, "cache lookup failed for opclass %u", opclass);

        cla_tup = (Form_pg_opclass) GETSTRUCT(cla_ht);

        opfamily = cla_tup->opcfamily;

        opcintype = cla_tup->opcintype;

        ReleaseSysCache(cla_ht);

        op = get_opfamily_member_for_cmptype(opfamily, opcintype, opcintype, COMPARE_EQ);

        if (!OidIsValid(op))

          elog(ERROR, "missing equality operator for (%u,%u) in opfamily %u",

             opcintype, opcintype, opfamily);

        /*

         * If we find the same column with the same equality semantics

         * in more than one index, we only need to emit the equality

         * clause once.

         *

         * Since we only remember the last equality operator, this

         * code could be fooled into emitting duplicate clauses given

         * multiple indexes with several different opclasses ... but

         * that's so unlikely it doesn't seem worth spending extra

         * code to avoid.

         */

        if (opUsedForQual[attnum - 1] == op)

          continue;

        opUsedForQual[attnum - 1] = op;

        /*

         * Actually add the qual, ANDed with any others.

         */

        if (foundUniqueIndex)

          appendStringInfoString(&querybuf, " AND ");

        leftop = quote_qualified_identifier("newdata",

                          NameStr(attr->attname));

        rightop = quote_qualified_identifier("mv",

                           NameStr(attr->attname));

        generate_operator_clause(&querybuf,

                     leftop, attrtype,

                     op,

                     rightop, attrtype);

        foundUniqueIndex = true;

      }

    }

    /* Keep the locks, since we're about to run DML which needs them. */

    index_close(indexRel, NoLock);

  }

  list_free(indexoidlist);

  /*

   * There must be at least one usable unique index on the matview.

   *

   * ExecRefreshMatView() checks that after taking the exclusive lock on the

   * matview. So at least one unique index is guaranteed to exist here

   * because the lock is still being held.  (One known exception is if a

   * function called as part of refreshing the matview drops the index.

   * That's a pretty silly thing to do.)

   */

  if (!foundUniqueIndex)

    ereport(ERROR,

        errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

        errmsg("could not find suitable unique index on materialized view \"%s\"",

             RelationGetRelationName(matviewRel)));

  appendStringInfoString(&querybuf,

               " AND newdata.* OPERATOR(pg_catalog.*=) mv.*) "

               "WHERE newdata.* IS NULL OR mv.* IS NULL "

               "ORDER BY tid");

  /* Populate the temporary "diff" table. */

  if (SPI_exec(querybuf.data, 0) != SPI_OK_INSERT)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  /*

   * We have no further use for data from the "full-data" temp table, but we

   * must keep it around because its type is referenced from the diff table.

   */

  /* Analyze the diff table. */

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf, "ANALYZE %s", diffname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_UTILITY)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  OpenMatViewIncrementalMaintenance();

  /* Deletes must come before inserts; do them first. */

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf,

           "DELETE FROM %s mv WHERE ctid OPERATOR(pg_catalog.=) ANY "

           "(SELECT diff.tid FROM %s diff "

           "WHERE diff.tid IS NOT NULL "

           "AND diff.newdata IS NULL)",

           matviewname, diffname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_DELETE)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  /* Inserts go last. */

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf,

           "INSERT INTO %s SELECT (diff.newdata).* "

           "FROM %s diff WHERE tid IS NULL",

           matviewname, diffname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_INSERT)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  /* We're done maintaining the materialized view. */

  CloseMatViewIncrementalMaintenance();

  table_close(tempRel, NoLock);

  table_close(matviewRel, NoLock);

  /* Clean up temp tables. */

  resetStringInfo(&querybuf);

  appendStringInfo(&querybuf, "DROP TABLE %s, %s", diffname, tempname);

  if (SPI_exec(querybuf.data, 0) != SPI_OK_UTILITY)

    elog(ERROR, "SPI_exec failed: %s", querybuf.data);

  /* Close SPI context. */

  if (SPI_finish() != SPI_OK_FINISH)

    elog(ERROR, "SPI_finish failed");

}

/*

 * Swap the physical files of the target and transient tables, then rebuild

 * the target's indexes and throw away the transient table.  Security context

 * swapping is handled by the called function, so it is not needed here.

 */

static void

refresh_by_heap_swap(Oid matviewOid, Oid OIDNewHeap, char relpersistence)

{

  finish_heap_swap(matviewOid, OIDNewHeap, false, false, true, true,

           true,   /* reindex */

           RecentXmin, ReadNextMultiXactId(), relpersistence);

}

/*

 * Check whether specified index is usable for match merge.

 */

static bool

is_usable_unique_index(Relation indexRel)

{

  Form_pg_index indexStruct = indexRel->rd_index;

  /*

   * Must be unique, valid, immediate, non-partial, and be defined over

   * plain user columns (not expressions).

   */

  if (indexStruct->indisunique &&

    indexStruct->indimmediate &&

    indexStruct->indisvalid &&

    RelationGetIndexPredicate(indexRel) == NIL &&

    indexStruct->indnatts > 0)

  {

    /*

     * The point of groveling through the index columns individually is to

     * reject both index expressions and system columns.  Currently,

     * matviews couldn't have OID columns so there's no way to create an

     * index on a system column; but maybe someday that wouldn't be true,

     * so let's be safe.

     */

    int     numatts = indexStruct->indnatts;

    int     i;

    for (i = 0; i < numatts; i++)

    {

      int     attnum = indexStruct->indkey.values[i];

      if (attnum <= 0)

        return false;

    }

    return true;

  }

  return false;

}

/*

 * This should be used to test whether the backend is in a context where it is

 * OK to allow DML statements to modify materialized views.  We only want to

 * allow that for internal code driven by the materialized view definition,

 * not for arbitrary user-supplied code.

 *

 * While the function names reflect the fact that their main intended use is

 * incremental maintenance of materialized views (in response to changes to

 * the data in referenced relations), they are initially used to allow REFRESH

 * without blocking concurrent reads.

 */

bool