<refsynopsisdiv>
<synopsis>
-REINDEX { INDEX | TABLE | SCHEMA | DATABASE | SYSTEM } <replaceable class="PARAMETER">name</replaceable>
+REINDEX [ ( { VERBOSE } [, ...] ) ] { INDEX | TABLE | SCHEMA | DATABASE | SYSTEM } <replaceable class="PARAMETER">name</replaceable>
</synopsis>
</refsynopsisdiv>
</para>
</listitem>
</varlistentry>
+
+ <varlistentry>
+ <term><literal>VERBOSE</literal></term>
+ <listitem>
+ <para>
+ Prints a progress report as each index is reindexed.
+ </para>
+ </listitem>
+ </varlistentry>
</variablelist>
</refsect1>
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
+#include "utils/pg_rusage.h"
#include "utils/syscache.h"
#include "utils/tuplesort.h"
#include "utils/snapmgr.h"
* reindex_index - This routine is used to recreate a single index
*/
void
-reindex_index(Oid indexId, bool skip_constraint_checks, char persistence)
+reindex_index(Oid indexId, bool skip_constraint_checks, char persistence,
+ int options)
{
Relation iRel,
heapRelation;
Oid heapId;
IndexInfo *indexInfo;
volatile bool skipped_constraint = false;
+ PGRUsage ru0;
+
+ pg_rusage_init(&ru0);
/*
* Open and lock the parent heap relation. ShareLock is sufficient since
heap_close(pg_index, RowExclusiveLock);
}
+ /* Log what we did */
+ if (options & REINDEXOPT_VERBOSE)
+ ereport(INFO,
+ (errmsg("index \"%s\" was reindexed",
+ get_rel_name(indexId)),
+ errdetail("%s.",
+ pg_rusage_show(&ru0))));
+
/* Close rels, but keep locks */
index_close(iRel, NoLock);
heap_close(heapRelation, NoLock);
* index rebuild.
*/
bool
-reindex_relation(Oid relid, int flags)
+reindex_relation(Oid relid, int flags, int options)
{
Relation rel;
Oid toast_relid;
RelationSetIndexList(rel, doneIndexes, InvalidOid);
reindex_index(indexOid, !(flags & REINDEX_REL_CHECK_CONSTRAINTS),
- persistence);
+ persistence, options);
CommandCounterIncrement();
* still hold the lock on the master table.
*/
if ((flags & REINDEX_REL_PROCESS_TOAST) && OidIsValid(toast_relid))
- result |= reindex_relation(toast_relid, flags);
+ result |= reindex_relation(toast_relid, flags, options);
return result;
}
else if (newrelpersistence == RELPERSISTENCE_PERMANENT)
reindex_flags |= REINDEX_REL_FORCE_INDEXES_PERMANENT;
- reindex_relation(OIDOldHeap, reindex_flags);
+ reindex_relation(OIDOldHeap, reindex_flags, 0);
/*
* If the relation being rebuild is pg_class, swap_relation_files()
* Recreate a specific index.
*/
Oid
-ReindexIndex(RangeVar *indexRelation)
+ReindexIndex(RangeVar *indexRelation, int options)
{
Oid indOid;
Oid heapOid = InvalidOid;
persistence = irel->rd_rel->relpersistence;
index_close(irel, NoLock);
- reindex_index(indOid, false, persistence);
+ reindex_index(indOid, false, persistence, options);
return indOid;
}
* Recreate all indexes of a table (and of its toast table, if any)
*/
Oid
-ReindexTable(RangeVar *relation)
+ReindexTable(RangeVar *relation, int options)
{
Oid heapOid;
if (!reindex_relation(heapOid,
REINDEX_REL_PROCESS_TOAST |
- REINDEX_REL_CHECK_CONSTRAINTS))
+ REINDEX_REL_CHECK_CONSTRAINTS,
+ options))
ereport(NOTICE,
(errmsg("table \"%s\" has no indexes",
relation->relname)));
* That means this must not be called within a user transaction block!
*/
void
-ReindexMultipleTables(const char *objectName, ReindexObjectType objectKind)
+ReindexMultipleTables(const char *objectName, ReindexObjectType objectKind,
+ int options)
{
Oid objectOid;
Relation relationRelation;
PushActiveSnapshot(GetTransactionSnapshot());
if (reindex_relation(relid,
REINDEX_REL_PROCESS_TOAST |
- REINDEX_REL_CHECK_CONSTRAINTS))
- ereport(DEBUG1,
- (errmsg("table \"%s.%s\" was reindexed",
- get_namespace_name(get_rel_namespace(relid)),
- get_rel_name(relid))));
+ REINDEX_REL_CHECK_CONSTRAINTS,
+ options))
+
+ if (options & REINDEXOPT_VERBOSE)
+ ereport(INFO,
+ (errmsg("table \"%s.%s\" was reindexed",
+ get_namespace_name(get_rel_namespace(relid)),
+ get_rel_name(relid))));
PopActiveSnapshot();
CommitTransactionCommand();
}
/*
* Reconstruct the indexes to match, and we're done.
*/
- reindex_relation(heap_relid, REINDEX_REL_PROCESS_TOAST);
+ reindex_relation(heap_relid, REINDEX_REL_PROCESS_TOAST, 0);
}
pgstat_count_truncate(rel);
COPY_SCALAR_FIELD(kind);
COPY_NODE_FIELD(relation);
COPY_STRING_FIELD(name);
+ COPY_SCALAR_FIELD(options);
return newnode;
}
COMPARE_SCALAR_FIELD(kind);
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(name);
+ COMPARE_SCALAR_FIELD(options);
return true;
}
%type <node> explain_option_arg
%type <defelt> explain_option_elem
%type <list> explain_option_list
+
+%type <ival> reindex_target_type reindex_target_multitable
+%type <ival> reindex_option_list reindex_option_elem
+
%type <node> copy_generic_opt_arg copy_generic_opt_arg_list_item
%type <defelt> copy_generic_opt_elem
%type <list> copy_generic_opt_list copy_generic_opt_arg_list
*
* QUERY:
*
- * REINDEX type <name>
+ * REINDEX [ (options) ] type <name>
*****************************************************************************/
ReindexStmt:
- REINDEX INDEX qualified_name
+ REINDEX reindex_target_type qualified_name
{
ReindexStmt *n = makeNode(ReindexStmt);
- n->kind = REINDEX_OBJECT_INDEX;
+ n->kind = $2;
n->relation = $3;
n->name = NULL;
+ n->options = 0;
$$ = (Node *)n;
}
- | REINDEX TABLE qualified_name
+ | REINDEX reindex_target_multitable name
{
ReindexStmt *n = makeNode(ReindexStmt);
- n->kind = REINDEX_OBJECT_TABLE;
- n->relation = $3;
- n->name = NULL;
- $$ = (Node *)n;
- }
- | REINDEX SCHEMA name
- {
- ReindexStmt *n = makeNode(ReindexStmt);
- n->kind = REINDEX_OBJECT_SCHEMA;
+ n->kind = $2;
n->name = $3;
n->relation = NULL;
+ n->options = 0;
$$ = (Node *)n;
}
- | REINDEX SYSTEM_P name
+ | REINDEX '(' reindex_option_list ')' reindex_target_type qualified_name
{
ReindexStmt *n = makeNode(ReindexStmt);
- n->kind = REINDEX_OBJECT_SYSTEM;
- n->name = $3;
- n->relation = NULL;
+ n->kind = $5;
+ n->relation = $6;
+ n->name = NULL;
+ n->options = $3;
$$ = (Node *)n;
}
- | REINDEX DATABASE name
+ | REINDEX '(' reindex_option_list ')' reindex_target_multitable name
{
ReindexStmt *n = makeNode(ReindexStmt);
- n->kind = REINDEX_OBJECT_DATABASE;
- n->name = $3;
+ n->kind = $5;
+ n->name = $6;
n->relation = NULL;
+ n->options = $3;
$$ = (Node *)n;
}
;
-
+reindex_target_type:
+ INDEX { $$ = REINDEX_OBJECT_INDEX; }
+ | TABLE { $$ = REINDEX_OBJECT_TABLE; }
+ ;
+reindex_target_multitable:
+ SCHEMA { $$ = REINDEX_OBJECT_SCHEMA; }
+ | SYSTEM_P { $$ = REINDEX_OBJECT_SYSTEM; }
+ | DATABASE { $$ = REINDEX_OBJECT_DATABASE; }
+ ;
+reindex_option_list:
+ reindex_option_elem { $$ = $1; }
+ | reindex_option_list ',' reindex_option_elem { $$ = $1 | $3; }
+ ;
+reindex_option_elem:
+ VERBOSE { $$ = REINDEXOPT_VERBOSE; }
+ ;
/*****************************************************************************
*
switch (stmt->kind)
{
case REINDEX_OBJECT_INDEX:
- ReindexIndex(stmt->relation);
+ ReindexIndex(stmt->relation, stmt->options);
break;
case REINDEX_OBJECT_TABLE:
- ReindexTable(stmt->relation);
+ ReindexTable(stmt->relation, stmt->options);
break;
case REINDEX_OBJECT_SCHEMA:
case REINDEX_OBJECT_SYSTEM:
(stmt->kind == REINDEX_OBJECT_SCHEMA) ? "REINDEX SCHEMA" :
(stmt->kind == REINDEX_OBJECT_SYSTEM) ? "REINDEX SYSTEM" :
"REINDEX DATABASE");
- ReindexMultipleTables(stmt->name, stmt->kind);
+ ReindexMultipleTables(stmt->name, stmt->kind, stmt->options);
break;
default:
elog(ERROR, "unrecognized object type: %d",
extern void index_set_state_flags(Oid indexId, IndexStateFlagsAction action);
extern void reindex_index(Oid indexId, bool skip_constraint_checks,
- char relpersistence);
+ char relpersistence, int options);
/* Flag bits for reindex_relation(): */
#define REINDEX_REL_PROCESS_TOAST 0x01
#define REINDEX_REL_FORCE_INDEXES_UNLOGGED 0x08
#define REINDEX_REL_FORCE_INDEXES_PERMANENT 0x10
-extern bool reindex_relation(Oid relid, int flags);
+extern bool reindex_relation(Oid relid, int flags, int options);
extern bool ReindexIsProcessingHeap(Oid heapOid);
extern bool ReindexIsProcessingIndex(Oid indexOid);
bool check_rights,
bool skip_build,
bool quiet);
-extern Oid ReindexIndex(RangeVar *indexRelation);
-extern Oid ReindexTable(RangeVar *relation);
-extern void ReindexMultipleTables(const char *objectName, ReindexObjectType objectKind);
+extern Oid ReindexIndex(RangeVar *indexRelation, int options);
+extern Oid ReindexTable(RangeVar *relation, int options);
+extern void ReindexMultipleTables(const char *objectName, ReindexObjectType objectKind,
+ int options);
extern char *makeObjectName(const char *name1, const char *name2,
const char *label);
extern char *ChooseRelationName(const char *name1, const char *name2,
* REINDEX Statement
* ----------------------
*/
+
+/* Reindex options */
+#define REINDEXOPT_VERBOSE 1 << 0 /* print progress info */
+
typedef enum ReindexObjectType
{
REINDEX_OBJECT_INDEX, /* index */
ReindexObjectType kind; /* REINDEX_OBJECT_INDEX, REINDEX_OBJECT_TABLE, etc. */
RangeVar *relation; /* Table or index to reindex */
const char *name; /* name of database to reindex */
+ int options; /* Reindex options flags */
} ReindexStmt;
/* ----------------------
Index Cond: ((thousand = 1) AND (tenthous = 1001))
(2 rows)
+--
+-- REINDEX (VERBOSE)
+--
+CREATE TABLE reindex_verbose(id integer primary key);
+\set VERBOSITY terse
+REINDEX (VERBOSE) TABLE reindex_verbose;
+INFO: index "reindex_verbose_pkey" was reindexed
+DROP TABLE reindex_verbose;
--
-- REINDEX SCHEMA
--
explain (costs off)
select * from tenk1 where (thousand, tenthous) in ((1,1001), (null,null));
+--
+-- REINDEX (VERBOSE)
+--
+CREATE TABLE reindex_verbose(id integer primary key);
+\set VERBOSITY terse
+REINDEX (VERBOSE) TABLE reindex_verbose;
+DROP TABLE reindex_verbose;
+
--
-- REINDEX SCHEMA
--