<!--
-$PostgreSQL: pgsql/doc/src/sgml/maintenance.sgml,v 1.44 2005/06/13 02:40:04 neilc Exp $
+$PostgreSQL: pgsql/doc/src/sgml/maintenance.sgml,v 1.45 2005/06/22 21:14:28 tgl Exp $
-->
<chapter id="maintenance">
<para>
In some situations it is worthwhile to rebuild indexes periodically
- with the <command>REINDEX</> command. (There is also
- <filename>contrib/reindexdb</> which can reindex an entire database.)
+ with the <command>REINDEX</> command.
However, <productname>PostgreSQL</> 7.4 has substantially reduced the need
for this activity compared to earlier releases.
</para>
<!--
-$PostgreSQL: pgsql/doc/src/sgml/ref/reindex.sgml,v 1.26 2005/01/22 23:22:19 momjian Exp $
+$PostgreSQL: pgsql/doc/src/sgml/ref/reindex.sgml,v 1.27 2005/06/22 21:14:28 tgl Exp $
PostgreSQL documentation
-->
<refsynopsisdiv>
<synopsis>
-REINDEX { DATABASE | TABLE | INDEX } <replaceable class="PARAMETER">name</replaceable> [ FORCE ]
+REINDEX { INDEX | TABLE | DATABASE | SYSTEM } <replaceable class="PARAMETER">name</replaceable> [ FORCE ]
</synopsis>
</refsynopsisdiv>
<title>Description</title>
<para>
- <command>REINDEX</command> rebuilds an index based on the data
+ <command>REINDEX</command> rebuilds an index using the data
stored in the index's table, replacing the old copy of the index. There are
two main reasons to use <command>REINDEX</command>:
<variablelist>
<varlistentry>
- <term><literal>DATABASE</literal></term>
+ <term><literal>INDEX</literal></term>
<listitem>
<para>
- Recreate all system indexes of a specified database. Indexes on
- user tables are not processed. Also, indexes on shared system
- catalogs are skipped except in stand-alone mode (see below).
+ Recreate the specified index.
</para>
</listitem>
</varlistentry>
<term><literal>TABLE</literal></term>
<listitem>
<para>
- Recreate all indexes of a specified table. If the table has a
+ Recreate all indexes of the specified table. If the table has a
secondary <quote>TOAST</> table, that is reindexed as well.
</para>
</listitem>
</varlistentry>
<varlistentry>
- <term><literal>INDEX</literal></term>
+ <term><literal>DATABASE</literal></term>
<listitem>
<para>
- Recreate a specified index.
+ Recreate all indexes within the current database.
+ Indexes on shared system catalogs are skipped except in stand-alone mode
+ (see below).
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term><literal>SYSTEM</literal></term>
+ <listitem>
+ <para>
+ Recreate all indexes on system catalogs within the current database.
+ Indexes on user tables are not processed. Also, indexes on shared
+ system catalogs are skipped except in stand-alone mode (see below).
</para>
</listitem>
</varlistentry>
<term><replaceable class="PARAMETER">name</replaceable></term>
<listitem>
<para>
- The name of the specific database, table, or index to be
- reindexed. Table and index names may be schema-qualified.
- Presently, <command>REINDEX DATABASE</> can only reindex the current
- database, so its parameter must match the current database's name.
+ The name of the specific index, table, or database to be
+ reindexed. Index and table names may be schema-qualified.
+ Presently, <command>REINDEX DATABASE</> and <command>REINDEX SYSTEM</>
+ can only reindex the current database, so their parameter must match
+ the current database's name.
</para>
</listitem>
</varlistentry>
One way to do this is to shut down the postmaster and start a stand-alone
<productname>PostgreSQL</productname> server
with the <option>-P</option> option included on its command line.
- Then, <command>REINDEX DATABASE</>,
+ Then, <command>REINDEX DATABASE</>, <command>REINDEX SYSTEM</>,
<command>REINDEX TABLE</>, or <command>REINDEX INDEX</> can be
issued, depending on how much you want to reconstruct. If in
- doubt, use <command>REINDEX DATABASE</> to select
+ doubt, use <command>REINDEX SYSTEM</> to select
reconstruction of all system indexes in the database. Then quit
the standalone server session and restart the regular server.
See the <xref linkend="app-postgres"> reference page for more
<command>REINDEX</> does not.
</para>
+ <para>
+ Reindexing a single index or table requires being the owner of that
+ index or table. Reindexing a database requires being the owner of
+ the database (note that the owner can therefore rebuild indexes of
+ tables owned by other users). Of course, superusers can always
+ reindex anything.
+ </para>
+
+ <para>
+ Prior to <productname>PostgreSQL</productname> 8.1, <command>REINDEX
+ DATABASE</> processed only system indexes, not all indexes as one would
+ expect from the name. This has been changed to reduce the surprise
+ factor. The old behavior is available as <command>REINDEX SYSTEM</>.
+ </para>
+
<para>
Prior to <productname>PostgreSQL</productname> 7.4, <command>REINDEX
TABLE</> did not automatically process TOAST tables, and so those had
</para>
<para>
- Rebuild all system indexes in a particular database, without trusting them
- to be valid already:
+ Rebuild all indexes in a particular database, without trusting the
+ system indexes to be valid already:
<programlisting>
$ <userinput>export PGOPTIONS="-P"</userinput>
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/indexcmds.c,v 1.132 2005/06/21 00:35:05 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/indexcmds.c,v 1.133 2005/06/22 21:14:29 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* ReindexIndex
- * Recreate an index.
+ * Recreate a specific index.
*/
void
-ReindexIndex(RangeVar *indexRelation, bool force /* currently unused */ )
+ReindexIndex(RangeVar *indexRelation)
{
Oid indOid;
HeapTuple tuple;
/*
* ReindexTable
- * Recreate indexes of a table.
+ * Recreate all indexes of a table (and of its toast table, if any)
*/
void
-ReindexTable(RangeVar *relation, bool force /* currently unused */ )
+ReindexTable(RangeVar *relation)
{
Oid heapOid;
HeapTuple tuple;
* separate transaction, so we can release the lock on it right away.
*/
void
-ReindexDatabase(const char *dbname, bool force /* currently unused */ ,
- bool all)
+ReindexDatabase(const char *databaseName, bool do_system, bool do_user)
{
Relation relationRelation;
HeapScanDesc scan;
List *relids = NIL;
ListCell *l;
- AssertArg(dbname);
+ AssertArg(databaseName);
- if (strcmp(dbname, get_database_name(MyDatabaseId)) != 0)
+ if (strcmp(databaseName, get_database_name(MyDatabaseId)) != 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("can only reindex the currently open database")));
if (!pg_database_ownercheck(MyDatabaseId, GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_DATABASE,
- dbname);
+ databaseName);
/*
* We cannot run inside a user transaction block; if we were inside a
* transaction, then our commit- and start-transaction-command calls
* would not have the intended effect!
*/
- PreventTransactionChain((void *) dbname, "REINDEX DATABASE");
+ PreventTransactionChain((void *) databaseName, "REINDEX DATABASE");
/*
* Create a memory context that will survive forced transaction
* before we process any other tables. This is critical because
* reindexing itself will try to update pg_class.
*/
- old = MemoryContextSwitchTo(private_context);
- relids = lappend_oid(relids, RelationRelationId);
- MemoryContextSwitchTo(old);
+ if (do_system)
+ {
+ old = MemoryContextSwitchTo(private_context);
+ relids = lappend_oid(relids, RelationRelationId);
+ MemoryContextSwitchTo(old);
+ }
/*
* Scan pg_class to build a list of the relations we need to reindex.
if (classtuple->relkind != RELKIND_RELATION)
continue;
- if (!all) /* only system tables? */
+ /* Check user/system classification, and optionally skip */
+ if (IsSystemClass(classtuple))
+ {
+ if (!do_system)
+ continue;
+ }
+ else
{
- if (!IsSystemClass(classtuple))
+ if (!do_user)
continue;
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.307 2005/06/17 22:32:43 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.308 2005/06/22 21:14:29 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COPY_SCALAR_FIELD(kind);
COPY_NODE_FIELD(relation);
COPY_STRING_FIELD(name);
- COPY_SCALAR_FIELD(force);
- COPY_SCALAR_FIELD(all);
+ COPY_SCALAR_FIELD(do_system);
+ COPY_SCALAR_FIELD(do_user);
return newnode;
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.244 2005/06/17 22:32:44 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/equalfuncs.c,v 1.245 2005/06/22 21:14:29 tgl Exp $
*
*-------------------------------------------------------------------------
*/
COMPARE_SCALAR_FIELD(kind);
COMPARE_NODE_FIELD(relation);
COMPARE_STRING_FIELD(name);
- COMPARE_SCALAR_FIELD(force);
- COMPARE_SCALAR_FIELD(all);
+ COMPARE_SCALAR_FIELD(do_system);
+ COMPARE_SCALAR_FIELD(do_user);
return true;
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.495 2005/06/17 22:32:44 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/gram.y,v 2.496 2005/06/22 21:14:29 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
SERIALIZABLE SESSION SESSION_USER SET SETOF SHARE
SHOW SIMILAR SIMPLE SMALLINT SOME STABLE START STATEMENT
STATISTICS STDIN STDOUT STORAGE STRICT_P SUBSTRING SYMMETRIC
- SYSID
+ SYSID SYSTEM_P
TABLE TABLESPACE TEMP TEMPLATE TEMPORARY THEN TIME TIMESTAMP
TO TOAST TRAILING TRANSACTION TREAT TRIGGER TRIM TRUE_P
*
* QUERY:
*
- * REINDEX type <typename> [FORCE] [ALL]
+ * REINDEX type <name> [FORCE]
*
+ * FORCE no longer does anything, but we accept it for backwards compatibility
*****************************************************************************/
ReindexStmt:
n->kind = $2;
n->relation = $3;
n->name = NULL;
- n->force = $4;
+ $$ = (Node *)n;
+ }
+ | REINDEX SYSTEM_P name opt_force
+ {
+ ReindexStmt *n = makeNode(ReindexStmt);
+ n->kind = OBJECT_DATABASE;
+ n->name = $3;
+ n->relation = NULL;
+ n->do_system = true;
+ n->do_user = false;
$$ = (Node *)n;
}
| REINDEX DATABASE name opt_force
n->kind = OBJECT_DATABASE;
n->name = $3;
n->relation = NULL;
- n->force = $4;
+ n->do_system = true;
+ n->do_user = true;
$$ = (Node *)n;
}
;
| STDOUT
| STORAGE
| SYSID
+ | SYSTEM_P
| STRICT_P
| TABLESPACE
| TEMP
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.157 2005/06/17 22:32:44 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/keywords.c,v 1.158 2005/06/22 21:14:30 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{"substring", SUBSTRING},
{"symmetric", SYMMETRIC},
{"sysid", SYSID},
+ {"system", SYSTEM_P},
{"table", TABLE},
{"tablespace", TABLESPACE},
{"temp", TEMP},
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/tcop/utility.c,v 1.237 2005/06/17 22:32:46 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/tcop/utility.c,v 1.238 2005/06/22 21:14:30 tgl Exp $
*
*-------------------------------------------------------------------------
*/
switch (stmt->kind)
{
case OBJECT_INDEX:
- ReindexIndex(stmt->relation, stmt->force);
+ ReindexIndex(stmt->relation);
break;
case OBJECT_TABLE:
- ReindexTable(stmt->relation, stmt->force);
+ ReindexTable(stmt->relation);
break;
case OBJECT_DATABASE:
- ReindexDatabase(stmt->name, stmt->force, false);
+ ReindexDatabase(stmt->name,
+ stmt->do_system, stmt->do_user);
break;
default:
elog(ERROR, "unrecognized object type: %d",
*
* Copyright (c) 2000-2005, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/bin/psql/common.c,v 1.103 2005/06/17 22:32:47 tgl Exp $
+ * $PostgreSQL: pgsql/src/bin/psql/common.c,v 1.104 2005/06/22 21:14:30 tgl Exp $
*/
#include "postgres_fe.h"
#include "common.h"
return true;
/*
- * Note: these tests will match REINDEX TABLESPACE, which isn't really
- * a valid command so we don't care much. The other five possible
- * matches are correct.
+ * Note: these tests will match CREATE SYSTEM, DROP SYSTEM, and
+ * REINDEX TABLESPACE, which aren't really valid commands so we don't
+ * care much. The other six possible matches are correct.
*/
if ((wordlen == 6 && pg_strncasecmp(query, "create", 6) == 0) ||
(wordlen == 4 && pg_strncasecmp(query, "drop", 4) == 0) ||
if (wordlen == 8 && pg_strncasecmp(query, "database", 8) == 0)
return true;
+ if (wordlen == 6 && pg_strncasecmp(query, "system", 6) == 0)
+ return true;
if (wordlen == 10 && pg_strncasecmp(query, "tablespace", 10) == 0)
return true;
}
*
* Copyright (c) 2000-2005, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/bin/psql/tab-complete.c,v 1.132 2005/06/21 00:48:33 neilc Exp $
+ * $PostgreSQL: pgsql/src/bin/psql/tab-complete.c,v 1.133 2005/06/22 21:14:30 tgl Exp $
*/
/*----------------------------------------------------------------------
else if (pg_strcasecmp(prev_wd, "REINDEX") == 0)
{
static const char *const list_REINDEX[] =
- {"TABLE", "DATABASE", "INDEX", NULL};
+ {"TABLE", "INDEX", "SYSTEM", "DATABASE", NULL};
COMPLETE_WITH_LIST(list_REINDEX);
}
{
if (pg_strcasecmp(prev_wd, "TABLE") == 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
- else if (pg_strcasecmp(prev_wd, "DATABASE") == 0)
- COMPLETE_WITH_QUERY(Query_for_list_of_databases);
else if (pg_strcasecmp(prev_wd, "INDEX") == 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_indexes, NULL);
+ else if (pg_strcasecmp(prev_wd, "SYSTEM") == 0 ||
+ pg_strcasecmp(prev_wd, "DATABASE") == 0)
+ COMPLETE_WITH_QUERY(Query_for_list_of_databases);
}
/* SELECT */
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/commands/defrem.h,v 1.64 2005/04/14 01:38:21 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/commands/defrem.h,v 1.65 2005/06/22 21:14:31 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool skip_build,
bool quiet);
extern void RemoveIndex(RangeVar *relation, DropBehavior behavior);
-extern void ReindexIndex(RangeVar *indexRelation, bool force);
-extern void ReindexTable(RangeVar *relation, bool force);
-extern void ReindexDatabase(const char *databaseName, bool force, bool all);
+extern void ReindexIndex(RangeVar *indexRelation);
+extern void ReindexTable(RangeVar *relation);
+extern void ReindexDatabase(const char *databaseName,
+ bool do_system, bool do_user);
extern char *makeObjectName(const char *name1, const char *name2,
const char *label);
extern char *ChooseRelationName(const char *name1, const char *name2,
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.282 2005/06/17 22:32:49 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/nodes/parsenodes.h,v 1.283 2005/06/22 21:14:31 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* OBJECT_DATABASE */
RangeVar *relation; /* Table or index to reindex */
const char *name; /* name of database to reindex */
- bool force;
- bool all;
+ bool do_system; /* include system tables in database case */
+ bool do_user; /* include user tables in database case */
} ReindexStmt;
/* ----------------------
projects / postgresql / commitdiff