database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-08-07 02:42:48 +03:00
Code Activity

Allow a VACUUM operation to change the page-size in the same way as it can be used to change a database between auto-vacuum and normal mode. (CVS 4896)

Browse Source 
FossilOrigin-Name: 871df0e7c36a88f175cfc63797745e52a1b1796b
This commit is contained in:
danielk1977
2008-03-20 11:04:21 +00:00
parent f219f196f8
commit f653d78282
10 changed files with 268 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
src/btree.c
View File

@@ -9,7 +9,7 @@
** May you share freely, never taking more than you give.
**
*************************************************************************
** $Id: btree.c,v 1.440 2008/03/04 17:45:01 mlcreech Exp $
** $Id: btree.c,v 1.441 2008/03/20 11:04:21 danielk1977 Exp $
**
** This file implements a external (disk-based) database using BTrees.
** See the header comment on "btreeInt.h" for additional information.
@@ -1635,20 +1635,21 @@ int sqlite3BtreeGetAutoVacuum(Btree *p){
** is returned if we run out of memory.
*/
static int lockBtree(BtShared *pBt){
int rc, pageSize;
int rc;
MemPage *pPage1;
assert( sqlite3_mutex_held(pBt->mutex) );
if( pBt->pPage1 ) return SQLITE_OK;
rc = sqlite3BtreeGetPage(pBt, 1, &pPage1, 0);
if( rc!=SQLITE_OK ) return rc;
/* Do some checking to help insure the file we opened really is
** a valid database file.
*/
rc = SQLITE_NOTADB;
if( sqlite3PagerPagecount(pBt->pPager)>0 ){
int pageSize;
int usableSize;
u8 *page1 = pPage1->aData;
if( memcmp(page1, zMagicHeader, 16)!=0 ){
goto page1_init_failed;
@@ -1666,11 +1667,25 @@ static int lockBtree(BtShared *pBt){
goto page1_init_failed;
}
assert( (pageSize & 7)==0 );
pBt->pageSize = pageSize;
pBt->usableSize = pageSize - page1[20];
if( pBt->usableSize<500 ){
usableSize = pageSize - page1[20];
if( pageSize!=pBt->pageSize ){
/* After reading the first page of the database assuming a page size
** of BtShared.pageSize, we have discovered that the page-size is
** actually pageSize. Unlock the database, leave pBt->pPage1 at
** zero and return SQLITE_OK. The caller will call this function
** again with the correct page-size.
*/
releasePage(pPage1);
pBt->usableSize = usableSize;
pBt->pageSize = pageSize;
sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
return SQLITE_OK;
}
if( usableSize<500 ){
goto page1_init_failed;
}
pBt->pageSize = pageSize;
pBt->usableSize = usableSize;
pBt->maxEmbedFrac = page1[21];
pBt->minEmbedFrac = page1[22];
pBt->minLeafFrac = page1[23];
@@ -1879,7 +1894,7 @@ int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
#endif
do {
if( pBt->pPage1==0 ){
while( rc==SQLITE_OK && pBt->pPage1==0 ){
rc = lockBtree(pBt);
}
@@ -2359,7 +2374,7 @@ int sqlite3BtreeCommitPhaseOne(Btree *p, const char *zMaster){
}
}
#endif
rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, nTrunc);
rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, nTrunc, 0);
sqlite3BtreeLeave(p);
}
return rc;
@@ -6729,62 +6744,209 @@ const char *sqlite3BtreeGetJournalname(Btree *p){
** Copy the complete content of pBtFrom into pBtTo. A transaction
** must be active for both files.
**
** The size of file pBtFrom may be reduced by this operation.
** If anything goes wrong, the transaction on pBtFrom is rolled back.
** The size of file pTo may be reduced by this operation.
** If anything goes wrong, the transaction on pTo is rolled back.
**
** If successful, CommitPhaseOne() may be called on pTo before returning.
** The caller should finish committing the transaction on pTo by calling
** sqlite3BtreeCommit().
*/
static int btreeCopyFile(Btree *pTo, Btree *pFrom){
int rc = SQLITE_OK;
Pgno i, nPage, nToPage, iSkip;
Pgno i;
Pgno nFromPage; /* Number of pages in pFrom */
Pgno nToPage; /* Number of pages in pTo */
Pgno nNewPage; /* Number of pages in pTo after the copy */
Pgno iSkip; /* Pending byte page in pTo */
int nToPageSize; /* Page size of pTo in bytes */
int nFromPageSize; /* Page size of pFrom in bytes */
BtShared *pBtTo = pTo->pBt;
BtShared *pBtFrom = pFrom->pBt;
pBtTo->db = pTo->db;
pBtFrom->db = pFrom->db;
nToPageSize = pBtTo->pageSize;
nFromPageSize = pBtFrom->pageSize;
if( pTo->inTrans!=TRANS_WRITE || pFrom->inTrans!=TRANS_WRITE ){
return SQLITE_ERROR;
}
if( pBtTo->pCursor ) return SQLITE_BUSY;
nToPage = sqlite3PagerPagecount(pBtTo->pPager);
nPage = sqlite3PagerPagecount(pBtFrom->pPager);
iSkip = PENDING_BYTE_PAGE(pBtTo);
for(i=1; rc==SQLITE_OK && i<=nPage; i++){
DbPage *pDbPage;
if( i==iSkip ) continue;
rc = sqlite3PagerGet(pBtFrom->pPager, i, &pDbPage);
if( rc ) break;
rc = sqlite3PagerOverwrite(pBtTo->pPager, i, sqlite3PagerGetData(pDbPage));
sqlite3PagerUnref(pDbPage);
if( pBtTo->pCursor ){
return SQLITE_BUSY;
}
/* If the file is shrinking, journal the pages that are being truncated
** so that they can be rolled back if the commit fails.
nToPage = sqlite3PagerPagecount(pBtTo->pPager);
nFromPage = sqlite3PagerPagecount(pBtFrom->pPager);
iSkip = PENDING_BYTE_PAGE(pBtTo);
/* Variable nNewPage is the number of pages required to store the
** contents of pFrom using the current page-size of pTo.
*/
for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){
DbPage *pDbPage;
if( i==iSkip ) continue;
rc = sqlite3PagerGet(pBtTo->pPager, i, &pDbPage);
if( rc ) break;
rc = sqlite3PagerWrite(pDbPage);
sqlite3PagerDontWrite(pDbPage);
/* Yeah. It seems wierd to call DontWrite() right after Write(). But
** that is because the names of those procedures do not exactly
** represent what they do. Write() really means "put this page in the
** rollback journal and mark it as dirty so that it will be written
** to the database file later." DontWrite() undoes the second part of
** that and prevents the page from being written to the database. The
** page is still on the rollback journal, though. And that is the whole
** point of this loop: to put pages on the rollback journal. */
sqlite3PagerUnref(pDbPage);
nNewPage = ((i64)nFromPage * (i64)nFromPageSize + (i64)nToPageSize - 1) /
(i64)nToPageSize;
for(i=1; rc==SQLITE_OK && (i<=nToPage || i<=nNewPage); i++){
/* Journal the original page.
**
** iSkip is the page number of the locking page (PENDING_BYTE_PAGE)
** in database *pTo (before the copy). This page is never written
** into the journal file. Unless i==iSkip or the page was not
** present in pTo before the copy operation, journal page i from pTo.
*/
if( i!=iSkip && i<=nToPage ){
DbPage *pDbPage;
rc = sqlite3PagerGet(pBtTo->pPager, i, &pDbPage);
if( rc ){
break;
}
rc = sqlite3PagerWrite(pDbPage);
if( rc ){
break;
}
if( i>nFromPage ){
/* Yeah. It seems wierd to call DontWrite() right after Write(). But
** that is because the names of those procedures do not exactly
** represent what they do. Write() really means "put this page in the
** rollback journal and mark it as dirty so that it will be written
** to the database file later." DontWrite() undoes the second part of
** that and prevents the page from being written to the database. The
** page is still on the rollback journal, though. And that is the
** whole point of this block: to put pages on the rollback journal.
*/
sqlite3PagerDontWrite(pDbPage);
}
sqlite3PagerUnref(pDbPage);
}
/* Overwrite the data in page i of the target database */
if( rc==SQLITE_OK && i!=iSkip && i<=nNewPage ){
DbPage *pToPage = 0;
sqlite3_int64 iOff;
rc = sqlite3PagerGet(pBtTo->pPager, i, &pToPage);
if( rc==SQLITE_OK ){
rc = sqlite3PagerWrite(pToPage);
}
for(
iOff=(i-1)*nToPageSize;
rc==SQLITE_OK && iOff<i*nToPageSize;
iOff += nFromPageSize
){
DbPage *pFromPage = 0;
Pgno iFrom = (iOff/nFromPageSize)+1;
if( iFrom==PENDING_BYTE_PAGE(pBtFrom) ){
continue;
}
rc = sqlite3PagerGet(pBtFrom->pPager, iFrom, &pFromPage);
if( rc==SQLITE_OK ){
char *zTo = sqlite3PagerGetData(pToPage);
char *zFrom = sqlite3PagerGetData(pFromPage);
int nCopy;
if( nFromPageSize>=nToPageSize ){
zFrom += ((i-1)*nToPageSize - ((iFrom-1)*nFromPageSize));
nCopy = nToPageSize;
}else{
zTo += (((iFrom-1)*nFromPageSize) - (i-1)*nToPageSize);
nCopy = nFromPageSize;
}
memcpy(zTo, zFrom, nCopy);
sqlite3PagerUnref(pFromPage);
}
}
if( pToPage ) sqlite3PagerUnref(pToPage);
}
}
if( !rc && nPage<nToPage ){
rc = sqlite3PagerTruncate(pBtTo->pPager, nPage);
/* If things have worked so far, the database file may need to be
** truncated. The complex part is that it may need to be truncated to
** a size that is not an integer multiple of nToPageSize - the current
** page size used by the pager associated with B-Tree pTo.
**
** For example, say the page-size of pTo is 2048 bytes and the original
** number of pages is 5 (10 KB file). If pFrom has a page size of 1024
** bytes and 9 pages, then the file needs to be truncated to 9KB.
*/
if( rc==SQLITE_OK ){
if( nFromPageSize!=nToPageSize ){
sqlite3_file *pFile = sqlite3PagerFile(pBtTo->pPager);
i64 iSize = (i64)nFromPageSize * (i64)nFromPage;
i64 iNow = (i64)((nToPage>nNewPage)?nToPage:nNewPage) * (i64)nToPageSize;
i64 iPending = ((i64)PENDING_BYTE_PAGE(pBtTo)-1) *(i64)nToPageSize;
assert( iSize<=iNow );
/* Commit phase one syncs the journal file associated with pTo
** containing the original data. It does not sync the database file
** itself. After doing this it is safe to use OsTruncate() and other
** file APIs on the database file directly.
*/
pBtTo->db = pTo->db;
rc = sqlite3PagerCommitPhaseOne(pBtTo->pPager, 0, 0, 1);
if( iSize<iNow && rc==SQLITE_OK ){
rc = sqlite3OsTruncate(pFile, iSize);
}
/* The loop that copied data from database pFrom to pTo did not
** populate the locking page of database pTo. If the page-size of
** pFrom is smaller than that of pTo, this means some data will
** not have been copied.
**
** This block copies the missing data from database pFrom to pTo
** using file APIs. This is safe because at this point we know that
** all of the original data from pTo has been synced into the
** journal file. At this point it would be safe to do anything at
** all to the database file except truncate it to zero bytes.
*/
if( rc==SQLITE_OK && nFromPageSize<nToPageSize && iSize>iPending){
i64 iOff;
for(
iOff=iPending;
rc==SQLITE_OK && iOff<(iPending+nToPageSize);
iOff += nFromPageSize
){
DbPage *pFromPage = 0;
Pgno iFrom = (iOff/nFromPageSize)+1;
if( iFrom==PENDING_BYTE_PAGE(pBtFrom) || iFrom>nFromPage ){
continue;
}
rc = sqlite3PagerGet(pBtFrom->pPager, iFrom, &pFromPage);
if( rc==SQLITE_OK ){
char *zFrom = sqlite3PagerGetData(pFromPage);
rc = sqlite3OsWrite(pFile, zFrom, nFromPageSize, iOff);
sqlite3PagerUnref(pFromPage);
}
}
}
/* Sync the database file */
if( rc==SQLITE_OK ){
rc = sqlite3PagerSync(pBtTo->pPager);
}
}else{
rc = sqlite3PagerTruncate(pBtTo->pPager, nNewPage);
}
if( rc==SQLITE_OK ){
pBtTo->pageSizeFixed = 0;
}
}
if( rc ){
sqlite3BtreeRollback(pTo);
}
return rc;
}
int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){