vacuum.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:9k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2003 April 6
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** This file contains code used to implement the VACUUM command.
  13. **
  14. ** Most of the code in this file may be omitted by defining the
  15. ** SQLITE_OMIT_VACUUM macro.
  16. **
  17. ** $Id: vacuum.c,v 1.77 2008/03/20 11:04:21 danielk1977 Exp $
  18. */
  19. #include "sqliteInt.h"
  20. #include "vdbeInt.h"
  21. #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
  22. /*
  23. ** Execute zSql on database db. Return an error code.
  24. */
  25. static int execSql(sqlite3 *db, const char *zSql){
  26.   sqlite3_stmt *pStmt;
  27.   if( !zSql ){
  28.     return SQLITE_NOMEM;
  29.   }
  30.   if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
  31.     return sqlite3_errcode(db);
  32.   }
  33.   while( SQLITE_ROW==sqlite3_step(pStmt) ){}
  34.   return sqlite3_finalize(pStmt);
  35. }
  36. /*
  37. ** Execute zSql on database db. The statement returns exactly
  38. ** one column. Execute this as SQL on the same database.
  39. */
  40. static int execExecSql(sqlite3 *db, const char *zSql){
  41.   sqlite3_stmt *pStmt;
  42.   int rc;
  43.   rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
  44.   if( rc!=SQLITE_OK ) return rc;
  45.   while( SQLITE_ROW==sqlite3_step(pStmt) ){
  46.     rc = execSql(db, (char*)sqlite3_column_text(pStmt, 0));
  47.     if( rc!=SQLITE_OK ){
  48.       sqlite3_finalize(pStmt);
  49.       return rc;
  50.     }
  51.   }
  52.   return sqlite3_finalize(pStmt);
  53. }
  54. /*
  55. ** The non-standard VACUUM command is used to clean up the database,
  56. ** collapse free space, etc.  It is modelled after the VACUUM command
  57. ** in PostgreSQL.
  58. **
  59. ** In version 1.0.x of SQLite, the VACUUM command would call
  60. ** gdbm_reorganize() on all the database tables.  But beginning
  61. ** with 2.0.0, SQLite no longer uses GDBM so this command has
  62. ** become a no-op.
  63. */
  64. void sqlite3Vacuum(Parse *pParse){
  65.   Vdbe *v = sqlite3GetVdbe(pParse);
  66.   if( v ){
  67.     sqlite3VdbeAddOp2(v, OP_Vacuum, 0, 0);
  68.   }
  69.   return;
  70. }
  71. /*
  72. ** This routine implements the OP_Vacuum opcode of the VDBE.
  73. */
  74. int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){
  75.   int rc = SQLITE_OK;     /* Return code from service routines */
  76.   Btree *pMain;           /* The database being vacuumed */
  77.   Btree *pTemp;           /* The temporary database we vacuum into */
  78.   char *zSql = 0;         /* SQL statements */
  79.   int saved_flags;        /* Saved value of the db->flags */
  80.   Db *pDb = 0;            /* Database to detach at end of vacuum */
  81.   int nRes;
  82.   /* Save the current value of the write-schema flag before setting it. */
  83.   saved_flags = db->flags;
  84.   db->flags |= SQLITE_WriteSchema | SQLITE_IgnoreChecks;
  85.   if( !db->autoCommit ){
  86.     sqlite3SetString(pzErrMsg, "cannot VACUUM from within a transaction", 
  87.        (char*)0);
  88.     rc = SQLITE_ERROR;
  89.     goto end_of_vacuum;
  90.   }
  91.   pMain = db->aDb[0].pBt;
  92.   /* Attach the temporary database as 'vacuum_db'. The synchronous pragma
  93.   ** can be set to 'off' for this file, as it is not recovered if a crash
  94.   ** occurs anyway. The integrity of the database is maintained by a
  95.   ** (possibly synchronous) transaction opened on the main database before
  96.   ** sqlite3BtreeCopyFile() is called.
  97.   **
  98.   ** An optimisation would be to use a non-journaled pager.
  99.   */
  100.   zSql = "ATTACH '' AS vacuum_db;";
  101.   rc = execSql(db, zSql);
  102.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  103.   pDb = &db->aDb[db->nDb-1];
  104.   assert( strcmp(db->aDb[db->nDb-1].zName,"vacuum_db")==0 );
  105.   pTemp = db->aDb[db->nDb-1].pBt;
  106.   nRes = sqlite3BtreeGetReserve(pMain);
  107.   if( sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain), nRes)
  108.    || sqlite3BtreeSetPageSize(pTemp, db->nextPagesize, nRes)
  109.    || db->mallocFailed 
  110.   ){
  111.     rc = SQLITE_NOMEM;
  112.     goto end_of_vacuum;
  113.   }
  114.   rc = execSql(db, "PRAGMA vacuum_db.synchronous=OFF");
  115.   if( rc!=SQLITE_OK ){
  116.     goto end_of_vacuum;
  117.   }
  118. #ifndef SQLITE_OMIT_AUTOVACUUM
  119.   sqlite3BtreeSetAutoVacuum(pTemp, db->nextAutovac>=0 ? db->nextAutovac :
  120.                                            sqlite3BtreeGetAutoVacuum(pMain));
  121. #endif
  122.   /* Begin a transaction */
  123.   rc = execSql(db, "BEGIN EXCLUSIVE;");
  124.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  125.   /* Query the schema of the main database. Create a mirror schema
  126.   ** in the temporary database.
  127.   */
  128.   rc = execExecSql(db, 
  129.       "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) "
  130.       "  FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence'"
  131.       "   AND rootpage>0"
  132.   );
  133.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  134.   rc = execExecSql(db, 
  135.       "SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14)"
  136.       "  FROM sqlite_master WHERE sql LIKE 'CREATE INDEX %' ");
  137.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  138.   rc = execExecSql(db, 
  139.       "SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21) "
  140.       "  FROM sqlite_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'");
  141.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  142.   /* Loop through the tables in the main database. For each, do
  143.   ** an "INSERT INTO vacuum_db.xxx SELECT * FROM xxx;" to copy
  144.   ** the contents to the temporary database.
  145.   */
  146.   rc = execExecSql(db, 
  147.       "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
  148.       "|| ' SELECT * FROM ' || quote(name) || ';'"
  149.       "FROM sqlite_master "
  150.       "WHERE type = 'table' AND name!='sqlite_sequence' "
  151.       "  AND rootpage>0"
  152.   );
  153.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  154.   /* Copy over the sequence table
  155.   */
  156.   rc = execExecSql(db, 
  157.       "SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' "
  158.       "FROM vacuum_db.sqlite_master WHERE name='sqlite_sequence' "
  159.   );
  160.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  161.   rc = execExecSql(db, 
  162.       "SELECT 'INSERT INTO vacuum_db.' || quote(name) "
  163.       "|| ' SELECT * FROM ' || quote(name) || ';' "
  164.       "FROM vacuum_db.sqlite_master WHERE name=='sqlite_sequence';"
  165.   );
  166.   if( rc!=SQLITE_OK ) goto end_of_vacuum;
  167.   /* Copy the triggers, views, and virtual tables from the main database
  168.   ** over to the temporary database.  None of these objects has any
  169.   ** associated storage, so all we have to do is copy their entries
  170.   ** from the SQLITE_MASTER table.
  171.   */
  172.   rc = execSql(db,
  173.       "INSERT INTO vacuum_db.sqlite_master "
  174.       "  SELECT type, name, tbl_name, rootpage, sql"
  175.       "    FROM sqlite_master"
  176.       "   WHERE type='view' OR type='trigger'"
  177.       "      OR (type='table' AND rootpage=0)"
  178.   );
  179.   if( rc ) goto end_of_vacuum;
  180.   /* At this point, unless the main db was completely empty, there is now a
  181.   ** transaction open on the vacuum database, but not on the main database.
  182.   ** Open a btree level transaction on the main database. This allows a
  183.   ** call to sqlite3BtreeCopyFile(). The main database btree level
  184.   ** transaction is then committed, so the SQL level never knows it was
  185.   ** opened for writing. This way, the SQL transaction used to create the
  186.   ** temporary database never needs to be committed.
  187.   */
  188.   if( rc==SQLITE_OK ){
  189.     u32 meta;
  190.     int i;
  191.     /* This array determines which meta meta values are preserved in the
  192.     ** vacuum.  Even entries are the meta value number and odd entries
  193.     ** are an increment to apply to the meta value after the vacuum.
  194.     ** The increment is used to increase the schema cookie so that other
  195.     ** connections to the same database will know to reread the schema.
  196.     */
  197.     static const unsigned char aCopy[] = {
  198.        1, 1,    /* Add one to the old schema cookie */
  199.        3, 0,    /* Preserve the default page cache size */
  200.        5, 0,    /* Preserve the default text encoding */
  201.        6, 0,    /* Preserve the user version */
  202.     };
  203.     assert( 1==sqlite3BtreeIsInTrans(pTemp) );
  204.     assert( 1==sqlite3BtreeIsInTrans(pMain) );
  205.     /* Copy Btree meta values */
  206.     for(i=0; i<sizeof(aCopy)/sizeof(aCopy[0]); i+=2){
  207.       rc = sqlite3BtreeGetMeta(pMain, aCopy[i], &meta);
  208.       if( rc!=SQLITE_OK ) goto end_of_vacuum;
  209.       rc = sqlite3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
  210.       if( rc!=SQLITE_OK ) goto end_of_vacuum;
  211.     }
  212.     rc = sqlite3BtreeCopyFile(pMain, pTemp);
  213.     if( rc!=SQLITE_OK ) goto end_of_vacuum;
  214.     rc = sqlite3BtreeCommit(pTemp);
  215.     if( rc!=SQLITE_OK ) goto end_of_vacuum;
  216.     rc = sqlite3BtreeCommit(pMain);
  217.   }
  218.   if( rc==SQLITE_OK ){
  219.     rc = sqlite3BtreeSetPageSize(pMain, sqlite3BtreeGetPageSize(pTemp), nRes);
  220.   }
  221. end_of_vacuum:
  222.   /* Restore the original value of db->flags */
  223.   db->flags = saved_flags;
  224.   /* Currently there is an SQL level transaction open on the vacuum
  225.   ** database. No locks are held on any other files (since the main file
  226.   ** was committed at the btree level). So it safe to end the transaction
  227.   ** by manually setting the autoCommit flag to true and detaching the
  228.   ** vacuum database. The vacuum_db journal file is deleted when the pager
  229.   ** is closed by the DETACH.
  230.   */
  231.   db->autoCommit = 1;
  232.   if( pDb ){
  233.     sqlite3BtreeClose(pDb->pBt);
  234.     pDb->pBt = 0;
  235.     pDb->pSchema = 0;
  236.   }
  237.   sqlite3ResetInternalSchema(db, 0);
  238.   return rc;
  239. }
  240. #endif  /* SQLITE_OMIT_VACUUM && SQLITE_OMIT_ATTACH */