You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
338 lines
11 KiB
338 lines
11 KiB
/*
|
|
** 2003 April 6
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
** This file contains code used to implement the VACUUM command.
|
|
**
|
|
** Most of the code in this file may be omitted by defining the
|
|
** SQLITE_OMIT_VACUUM macro.
|
|
**
|
|
** $Id: vacuum.c 548347 2006-06-05 10:53:00Z staniek $
|
|
*/
|
|
#include "sqliteInt.h"
|
|
#include "os.h"
|
|
|
|
#ifndef SQLITE_OMIT_VACUUM
|
|
/*
|
|
** Generate a random name of 20 character in length.
|
|
*/
|
|
static void randomName(unsigned char *zBuf){
|
|
static const unsigned char zChars[] =
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
"0123456789";
|
|
int i;
|
|
sqlite3Randomness(20, zBuf);
|
|
for(i=0; i<20; i++){
|
|
zBuf[i] = zChars[ zBuf[i]%(sizeof(zChars)-1) ];
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Execute zSql on database db. Return an error code.
|
|
*/
|
|
static int execSql(sqlite3 *db, const char *zSql){
|
|
sqlite3_stmt *pStmt;
|
|
if( SQLITE_OK!=sqlite3_prepare(db, zSql, -1, &pStmt, 0) ){
|
|
return sqlite3_errcode(db);
|
|
}
|
|
while( SQLITE_ROW==sqlite3_step(pStmt) );
|
|
return sqlite3_finalize(pStmt);
|
|
}
|
|
|
|
/* (jstaniek) */
|
|
extern int g_verbose_vacuum;
|
|
|
|
/*
|
|
** Execute zSql on database db. The statement returns exactly
|
|
** one column. Execute this as SQL on the same database.
|
|
**
|
|
** (js: extension): if count > 0, "VACUUM: X%" string will
|
|
** be printed to stdout, so user (a human or calling application)
|
|
** can know the overall progress of the operation.
|
|
** and the program will wait for a key press (followed by RETURN);
|
|
** 'q' key aborts the execution and any other key allows to proceed.
|
|
*/
|
|
static int execExecSql(sqlite3 *db, const char *zSql, int count){
|
|
sqlite3_stmt *pStmt;
|
|
int rc, i;
|
|
char ch;
|
|
|
|
rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
|
|
if( rc!=SQLITE_OK ) return rc;
|
|
|
|
for( i=0; SQLITE_ROW==sqlite3_step(pStmt); i++ ){
|
|
if (g_verbose_vacuum!=0 && count>0) {
|
|
fprintf(stdout, "VACUUM: %d%%\n", 100*(i+1)/count);
|
|
fflush(stdout);
|
|
fscanf(stdin, "%c", &ch);
|
|
if ('q'==ch) { /* quit */
|
|
sqlite3_finalize(pStmt);
|
|
return SQLITE_ABORT;
|
|
}
|
|
}
|
|
rc = execSql(db, sqlite3_column_text(pStmt, 0));
|
|
if( rc!=SQLITE_OK ){
|
|
sqlite3_finalize(pStmt);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return sqlite3_finalize(pStmt);
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
** The non-standard VACUUM command is used to clean up the database,
|
|
** collapse free space, etc. It is modelled after the VACUUM command
|
|
** in PostgreSQL.
|
|
**
|
|
** In version 1.0.x of SQLite, the VACUUM command would call
|
|
** gdbm_reorganize() on all the database tables. But beginning
|
|
** with 2.0.0, SQLite no longer uses GDBM so this command has
|
|
** become a no-op.
|
|
*/
|
|
void sqlite3Vacuum(Parse *pParse, Token *pTableName){
|
|
Vdbe *v = sqlite3GetVdbe(pParse);
|
|
if( v ){
|
|
sqlite3VdbeAddOp(v, OP_Vacuum, 0, 0);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/*
|
|
** This routine implements the OP_Vacuum opcode of the VDBE.
|
|
*/
|
|
int sqlite3RunVacuum(char **pzErrMsg, sqlite3 *db){
|
|
int rc = SQLITE_OK; /* Return code from service routines */
|
|
sqlite3_stmt *pStmt = 0;
|
|
int tables_count = 0;
|
|
#ifndef SQLITE_OMIT_VACUUM
|
|
const char *zFilename; /* full pathname of the database file */
|
|
int nFilename; /* number of characters in zFilename[] */
|
|
char *zTemp = 0; /* a temporary file in same directory as zFilename */
|
|
Btree *pMain; /* The database being vacuumed */
|
|
Btree *pTemp;
|
|
char *zSql = 0;
|
|
int writeschema_flag; /* Saved value of the write-schema flag */
|
|
|
|
/* Save the current value of the write-schema flag before setting it. */
|
|
writeschema_flag = db->flags&SQLITE_WriteSchema;
|
|
db->flags |= SQLITE_WriteSchema;
|
|
|
|
if( !db->autoCommit ){
|
|
sqlite3SetString(pzErrMsg, "cannot VACUUM from within a transaction",
|
|
(char*)0);
|
|
rc = SQLITE_ERROR;
|
|
goto end_of_vacuum;
|
|
}
|
|
|
|
/* Get the full pathname of the database file and create a
|
|
** temporary filename in the same directory as the original file.
|
|
*/
|
|
pMain = db->aDb[0].pBt;
|
|
zFilename = sqlite3BtreeGetFilename(pMain);
|
|
assert( zFilename );
|
|
if( zFilename[0]=='\0' ){
|
|
/* The in-memory database. Do nothing. Return directly to avoid causing
|
|
** an error trying to DETACH the vacuum_db (which never got attached)
|
|
** in the exit-handler.
|
|
*/
|
|
return SQLITE_OK;
|
|
}
|
|
nFilename = strlen(zFilename);
|
|
zTemp = sqliteMalloc( nFilename+100 );
|
|
if( zTemp==0 ){
|
|
rc = SQLITE_NOMEM;
|
|
goto end_of_vacuum;
|
|
}
|
|
strcpy(zTemp, zFilename);
|
|
|
|
/* The randomName() procedure in the following loop uses an excellent
|
|
** source of randomness to generate a name from a space of 1.3e+31
|
|
** possibilities. So unless the directory already contains on the order
|
|
** of 1.3e+31 files, the probability that the following loop will
|
|
** run more than once or twice is vanishingly small. We are certain
|
|
** enough that this loop will always terminate (and terminate quickly)
|
|
** that we don't even bother to set a maximum loop count.
|
|
*/
|
|
do {
|
|
zTemp[nFilename] = '-';
|
|
randomName((unsigned char*)&zTemp[nFilename+1]);
|
|
} while( sqlite3OsFileExists(zTemp) );
|
|
|
|
/* Attach the temporary database as 'vacuum_db'. The synchronous pragma
|
|
** can be set to 'off' for this file, as it is not recovered if a crash
|
|
** occurs anyway. The integrity of the database is maintained by a
|
|
** (possibly synchronous) transaction opened on the main database before
|
|
** sqlite3BtreeCopyFile() is called.
|
|
**
|
|
** An optimisation would be to use a non-journaled pager.
|
|
*/
|
|
zSql = sqlite3MPrintf("ATTACH '%q' AS vacuum_db;", zTemp);
|
|
if( !zSql ){
|
|
rc = SQLITE_NOMEM;
|
|
goto end_of_vacuum;
|
|
}
|
|
rc = execSql(db, zSql);
|
|
sqliteFree(zSql);
|
|
zSql = 0;
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
assert( strcmp(db->aDb[db->nDb-1].zName,"vacuum_db")==0 );
|
|
pTemp = db->aDb[db->nDb-1].pBt;
|
|
sqlite3BtreeSetPageSize(pTemp, sqlite3BtreeGetPageSize(pMain),
|
|
sqlite3BtreeGetReserve(pMain));
|
|
assert( sqlite3BtreeGetPageSize(pTemp)==sqlite3BtreeGetPageSize(pMain) );
|
|
execSql(db, "PRAGMA vacuum_db.synchronous=OFF");
|
|
|
|
#ifndef SQLITE_OMIT_AUTOVACUUM
|
|
sqlite3BtreeSetAutoVacuum(pTemp, sqlite3BtreeGetAutoVacuum(pMain));
|
|
#endif
|
|
|
|
/* Begin a transaction */
|
|
rc = execSql(db, "BEGIN;");
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
|
|
/* Query the schema of the main database. Create a mirror schema
|
|
** in the temporary database.
|
|
*/
|
|
rc = execExecSql(db,
|
|
"SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14,100000000) "
|
|
" FROM sqlite_master WHERE type='table' AND name!='sqlite_sequence'", 0);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
rc = execExecSql(db,
|
|
"SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14,100000000)"
|
|
" FROM sqlite_master WHERE sql LIKE 'CREATE INDEX %' ", 0);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
rc = execExecSql(db,
|
|
"SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21,100000000) "
|
|
" FROM sqlite_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'", 0);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
rc = execExecSql(db,
|
|
"SELECT 'CREATE VIEW vacuum_db.' || substr(sql,13,100000000) "
|
|
" FROM sqlite_master WHERE type='view'", 0
|
|
);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
|
|
/* (js) get # of tables so we can output progress.
|
|
*/
|
|
rc = sqlite3_prepare(db, "SELECT count(name) FROM sqlite_master "
|
|
"WHERE type = 'table';", -1, &pStmt, 0);
|
|
if( rc!=SQLITE_OK || SQLITE_ROW!=sqlite3_step(pStmt)) goto end_of_vacuum;
|
|
tables_count = atoi( sqlite3_column_text(pStmt, 0) );
|
|
|
|
/* Loop through the tables in the main database. For each, do
|
|
** an "INSERT INTO vacuum_db.xxx SELECT * FROM xxx;" to copy
|
|
** the contents to the temporary database.
|
|
*/
|
|
rc = execExecSql(db,
|
|
"SELECT 'INSERT INTO vacuum_db.' || quote(name) "
|
|
"|| ' SELECT * FROM ' || quote(name) || ';'"
|
|
"FROM sqlite_master "
|
|
"WHERE type = 'table' AND name!='sqlite_sequence';", tables_count
|
|
);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
|
|
/* Copy over the sequence table
|
|
*/
|
|
rc = execExecSql(db,
|
|
"SELECT 'DELETE FROM vacuum_db.' || quote(name) || ';' "
|
|
"FROM vacuum_db.sqlite_master WHERE name='sqlite_sequence' ", 0
|
|
);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
rc = execExecSql(db,
|
|
"SELECT 'INSERT INTO vacuum_db.' || quote(name) "
|
|
"|| ' SELECT * FROM ' || quote(name) || ';' "
|
|
"FROM vacuum_db.sqlite_master WHERE name=='sqlite_sequence';", 0
|
|
);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
|
|
|
|
/* Copy the triggers from the main database to the temporary database.
|
|
** This was deferred before in case the triggers interfered with copying
|
|
** the data. It's possible the indices should be deferred until this
|
|
** point also.
|
|
*/
|
|
rc = execExecSql(db,
|
|
"SELECT 'CREATE TRIGGER vacuum_db.' || substr(sql, 16, 1000000) "
|
|
"FROM sqlite_master WHERE type='trigger'", 0
|
|
);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
|
|
/* At this point, unless the main db was completely empty, there is now a
|
|
** transaction open on the vacuum database, but not on the main database.
|
|
** Open a btree level transaction on the main database. This allows a
|
|
** call to sqlite3BtreeCopyFile(). The main database btree level
|
|
** transaction is then committed, so the SQL level never knows it was
|
|
** opened for writing. This way, the SQL transaction used to create the
|
|
** temporary database never needs to be committed.
|
|
*/
|
|
if( sqlite3BtreeIsInTrans(pTemp) ){
|
|
u32 meta;
|
|
int i;
|
|
|
|
/* This array determines which meta meta values are preserved in the
|
|
** vacuum. Even entries are the meta value number and odd entries
|
|
** are an increment to apply to the meta value after the vacuum.
|
|
** The increment is used to increase the schema cookie so that other
|
|
** connections to the same database will know to reread the schema.
|
|
*/
|
|
static const unsigned char aCopy[] = {
|
|
1, 1, /* Add one to the old schema cookie */
|
|
3, 0, /* Preserve the default page cache size */
|
|
5, 0, /* Preserve the default text encoding */
|
|
6, 0, /* Preserve the user version */
|
|
};
|
|
|
|
assert( 0==sqlite3BtreeIsInTrans(pMain) );
|
|
rc = sqlite3BtreeBeginTrans(pMain, 1);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
|
|
/* Copy Btree meta values */
|
|
for(i=0; i<sizeof(aCopy)/sizeof(aCopy[0]); i+=2){
|
|
rc = sqlite3BtreeGetMeta(pMain, aCopy[i], &meta);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
rc = sqlite3BtreeUpdateMeta(pTemp, aCopy[i], meta+aCopy[i+1]);
|
|
}
|
|
|
|
rc = sqlite3BtreeCopyFile(pMain, pTemp);
|
|
if( rc!=SQLITE_OK ) goto end_of_vacuum;
|
|
rc = sqlite3BtreeCommit(pMain);
|
|
}
|
|
|
|
end_of_vacuum:
|
|
/* Restore the original value of the write-schema flag. */
|
|
db->flags &= ~SQLITE_WriteSchema;
|
|
db->flags |= writeschema_flag;
|
|
|
|
/* Currently there is an SQL level transaction open on the vacuum
|
|
** database. No locks are held on any other files (since the main file
|
|
** was committed at the btree level). So it safe to end the transaction
|
|
** by manually setting the autoCommit flag to true and detaching the
|
|
** vacuum database. The vacuum_db journal file is deleted when the pager
|
|
** is closed by the DETACH.
|
|
*/
|
|
db->autoCommit = 1;
|
|
if( rc==SQLITE_OK ){
|
|
rc = execSql(db, "DETACH vacuum_db;");
|
|
}else{
|
|
execSql(db, "DETACH vacuum_db;");
|
|
}
|
|
if( zTemp ){
|
|
sqlite3OsDelete(zTemp);
|
|
sqliteFree(zTemp);
|
|
}
|
|
if( zSql ) sqliteFree( zSql );
|
|
sqlite3ResetInternalSchema(db, 0);
|
|
#endif
|
|
|
|
return rc;
|
|
}
|