Fix up gcc warnings, improve comments.

diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c
index acbcd4ce11331c00b4d2c2fee93a9bf145d7c3b9..51f2ac15d1c4268b8dbe1bc68e9f30fe0754e825 100644 (file)
--- a/src/backend/commands/vacuum.c
+++ b/src/backend/commands/vacuum.c
@@ -13,7 +13,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.228 2002/06/15 19:54:23 momjian Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.229 2002/06/15 21:52:31 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -158,9 +158,8 @@ static bool enough_space(VacPage vacpage, Size len);
 void
 vacuum(VacuumStmt *vacstmt)
 {
-   MemoryContext anl_context,
-                 old_context;
    const char *stmttype = vacstmt->vacuum ? "VACUUM" : "ANALYZE";
+   MemoryContext anl_context = NULL;
    List       *vrl,
               *cur;
 
@@ -188,7 +187,8 @@ vacuum(VacuumStmt *vacstmt)
    /*
     * Send info about dead objects to the statistics collector
     */
-   pgstat_vacuum_tabstat();
+   if (vacstmt->vacuum)
+       pgstat_vacuum_tabstat();
 
    /*
     * Create special memory context for cross-transaction storage.
@@ -203,6 +203,10 @@ vacuum(VacuumStmt *vacstmt)
                                        ALLOCSET_DEFAULT_INITSIZE,
                                        ALLOCSET_DEFAULT_MAXSIZE);
 
+   /*
+    * If we are running only ANALYZE, we don't need per-table transactions,
+    * but we still need a memory context with table lifetime.
+    */
    if (vacstmt->analyze && !vacstmt->vacuum)
        anl_context = AllocSetContextCreate(QueryContext,
                                            "Analyze",
@@ -214,28 +218,40 @@ vacuum(VacuumStmt *vacstmt)
    vrl = getrels(vacstmt->relation, stmttype);
 
    /*
-    *      Formerly, there was code here to prevent more than one VACUUM from
-    *      executing concurrently in the same database.  However, there's no
-    *      good reason to prevent that, and manually removing lockfiles after
-    *      a vacuum crash was a pain for dbadmins.  So, forget about lockfiles,
-    *      and just rely on the locks we grab on each target table
-    *      to ensure that there aren't two VACUUMs running on the same table
-    *      at the same time.
+    * Formerly, there was code here to prevent more than one VACUUM from
+    * executing concurrently in the same database.  However, there's no
+    * good reason to prevent that, and manually removing lockfiles after
+    * a vacuum crash was a pain for dbadmins.  So, forget about lockfiles,
+    * and just rely on the locks we grab on each target table
+    * to ensure that there aren't two VACUUMs running on the same table
+    * at the same time.
+    */
+
+   /*
+    * The strangeness with committing and starting transactions here is due
+    * to wanting to run each table's VACUUM as a separate transaction, so
+    * that we don't hold locks unnecessarily long.  Also, if we are doing
+    * VACUUM ANALYZE, the ANALYZE part runs as a separate transaction from
+    * the VACUUM to further reduce locking.
+    *
+    * vacuum_rel expects to be entered with no transaction active; it will
+    * start and commit its own transaction.  But we are called by an SQL
+    * command, and so we are executing inside a transaction already.  We
+    * commit the transaction started in PostgresMain() here, and start
+    * another one before exiting to match the commit waiting for us back in
+    * PostgresMain().
     *
-    *      The strangeness with committing and starting transactions in the
-    *      init and shutdown routines is due to the fact that the vacuum cleaner
-    *      is invoked via an SQL command, and so is already executing inside
-    *      a transaction.  We need to leave ourselves in a predictable state
-    *      on entry and exit to the vacuum cleaner.  We commit the transaction
-    *      started in PostgresMain() inside vacuum_init(), and start one in
-    *      vacuum_shutdown() to match the commit waiting for us back in
-    *      PostgresMain().
+    * In the case of an ANALYZE statement (no vacuum, just analyze) it's
+    * okay to run the whole thing in the outer transaction, and so we skip
+    * transaction start/stop operations.
     */
    if (vacstmt->vacuum)
    {
        if (vacstmt->relation == NULL)
        {
            /*
+            * It's a database-wide VACUUM.
+            *
             * Compute the initially applicable OldestXmin and FreezeLimit
             * XIDs, so that we can record these values at the end of the
             * VACUUM. Note that individual tables may well be processed with
@@ -261,11 +277,7 @@ vacuum(VacuumStmt *vacstmt)
    }
 
    /*
-    * Process each selected relation.  We are careful to process each
-    * relation in a separate transaction in order to avoid holding too
-    * many locks at one time.  Also, if we are doing VACUUM ANALYZE, the
-    * ANALYZE part runs as a separate transaction from the VACUUM to
-    * further reduce locking.
+    * Loop to process each selected relation.
     */
    foreach(cur, vrl)
    {
@@ -275,7 +287,14 @@ vacuum(VacuumStmt *vacstmt)
            vacuum_rel(relid, vacstmt, RELKIND_RELATION);
        if (vacstmt->analyze)
        {
-           /* If we vacuumed, use new transaction for analyze. */
+           MemoryContext old_context = NULL;
+
+           /*
+            * If we vacuumed, use new transaction for analyze.  Otherwise,
+            * we can use the outer transaction, but we still need to call
+            * analyze_rel in a memory context that will be cleaned up on
+            * return (else we leak memory while processing multiple tables).
+            */
            if (vacstmt->vacuum)
                StartTransactionCommand();
            else
@@ -287,16 +306,18 @@ vacuum(VacuumStmt *vacstmt)
                CommitTransactionCommand();
            else
            {
-               MemoryContextResetAndDeleteChildren(anl_context);
                MemoryContextSwitchTo(old_context);
+               MemoryContextResetAndDeleteChildren(anl_context);
            }
        }
    }
 
-   /* clean up */
+   /*
+    * Finish up processing.
+    */
    if (vacstmt->vacuum)
    {
-       /* on entry, we are not in a transaction */
+       /* here, we are not in a transaction */
 
        /* matches the CommitTransaction in PostgresMain() */
        StartTransactionCommand();
@@ -322,9 +343,8 @@ vacuum(VacuumStmt *vacstmt)
    MemoryContextDelete(vac_context);
    vac_context = NULL;
 
-   if (vacstmt->analyze && !vacstmt->vacuum)
+   if (anl_context)
        MemoryContextDelete(anl_context);
-
 }
 
 /*