mirror of
https://github.com/sqlite/sqlite.git
synced 2025-07-29 08:01:23 +03:00
Remove some unnecessary code and complication from the btree interface. (CVS 909)
FossilOrigin-Name: 35cc7c7d37d9ca486e7f300efe80a78a7f1064e2
This commit is contained in:
drh
182
src/btree.c
182
src/btree.c
@ -9,7 +9,7 @@
|
||||
** May you share freely, never taking more than you give.
|
||||
**
|
||||
*************************************************************************
|
||||
** $Id: btree.c,v 1.88 2003/04/13 18:26:51 paul Exp $
|
||||
** $Id: btree.c,v 1.89 2003/04/16 01:28:16 drh Exp $
|
||||
**
|
||||
** This file implements a external (disk-based) database using BTrees.
|
||||
** For a detailed discussion of BTrees, refer to
|
||||
@ -49,13 +49,6 @@
|
||||
** BTree begins on page 2 of the file. (Pages are numbered beginning with
|
||||
** 1, not 0.) Thus a minimum database contains 2 pages.
|
||||
*/
|
||||
|
||||
/* We don't want the btree function macros as they clash with the functions
|
||||
** defined in this file. This may be fixed in future by renaming the macros
|
||||
** or the functions defined here, or both.
|
||||
*/
|
||||
#define SQLITE_NO_BTREE_DEFS
|
||||
|
||||
#include "sqliteInt.h"
|
||||
#include "pager.h"
|
||||
#include "btree.h"
|
||||
@ -389,7 +382,7 @@ struct BtCursor {
|
||||
#define SKIP_INVALID 3 /* Calls to Next() and Previous() are invalid */
|
||||
|
||||
/* Forward declarations */
|
||||
static int sqliteBtreeCloseCursor(BtCursor *pCur);
|
||||
static int fileBtreeCloseCursor(BtCursor *pCur);
|
||||
|
||||
/*
|
||||
** Routines for byte swapping.
|
||||
@ -733,9 +726,9 @@ int sqliteBtreeOpen(
|
||||
/*
|
||||
** Close an open database and invalidate all cursors.
|
||||
*/
|
||||
static int sqliteBtreeClose(Btree *pBt){
|
||||
static int fileBtreeClose(Btree *pBt){
|
||||
while( pBt->pCursor ){
|
||||
sqliteBtreeCloseCursor(pBt->pCursor);
|
||||
fileBtreeCloseCursor(pBt->pCursor);
|
||||
}
|
||||
sqlitepager_close(pBt->pPager);
|
||||
sqliteFree(pBt);
|
||||
@ -757,7 +750,7 @@ static int sqliteBtreeClose(Btree *pBt){
|
||||
** Synchronous is on by default so database corruption is not
|
||||
** normally a worry.
|
||||
*/
|
||||
static int sqliteBtreeSetCacheSize(Btree *pBt, int mxPage){
|
||||
static int fileBtreeSetCacheSize(Btree *pBt, int mxPage){
|
||||
sqlitepager_set_cachesize(pBt->pPager, mxPage);
|
||||
return SQLITE_OK;
|
||||
}
|
||||
@ -770,7 +763,7 @@ static int sqliteBtreeSetCacheSize(Btree *pBt, int mxPage){
|
||||
** is a very low but non-zero probability of damage. Level 3 reduces the
|
||||
** probability of damage to near zero but with a write performance reduction.
|
||||
*/
|
||||
static int sqliteBtreeSetSafetyLevel(Btree *pBt, int level){
|
||||
static int fileBtreeSetSafetyLevel(Btree *pBt, int level){
|
||||
sqlitepager_set_safety_level(pBt->pPager, level);
|
||||
return SQLITE_OK;
|
||||
}
|
||||
@ -877,7 +870,7 @@ static int newDatabase(Btree *pBt){
|
||||
** sqliteBtreeDelete()
|
||||
** sqliteBtreeUpdateMeta()
|
||||
*/
|
||||
static int sqliteBtreeBeginTrans(Btree *pBt){
|
||||
static int fileBtreeBeginTrans(Btree *pBt){
|
||||
int rc;
|
||||
if( pBt->inTrans ) return SQLITE_ERROR;
|
||||
if( pBt->readOnly ) return SQLITE_READONLY;
|
||||
@ -906,7 +899,7 @@ static int sqliteBtreeBeginTrans(Btree *pBt){
|
||||
** This will release the write lock on the database file. If there
|
||||
** are no active cursors, it also releases the read lock.
|
||||
*/
|
||||
static int sqliteBtreeCommit(Btree *pBt){
|
||||
static int fileBtreeCommit(Btree *pBt){
|
||||
int rc;
|
||||
rc = pBt->readOnly ? SQLITE_OK : sqlitepager_commit(pBt->pPager);
|
||||
pBt->inTrans = 0;
|
||||
@ -924,7 +917,7 @@ static int sqliteBtreeCommit(Btree *pBt){
|
||||
** This will release the write lock on the database file. If there
|
||||
** are no active cursors, it also releases the read lock.
|
||||
*/
|
||||
static int sqliteBtreeRollback(Btree *pBt){
|
||||
static int fileBtreeRollback(Btree *pBt){
|
||||
int rc;
|
||||
BtCursor *pCur;
|
||||
if( pBt->inTrans==0 ) return SQLITE_OK;
|
||||
@ -951,7 +944,7 @@ static int sqliteBtreeRollback(Btree *pBt){
|
||||
** Only one checkpoint may be active at a time. It is an error to try
|
||||
** to start a new checkpoint if another checkpoint is already active.
|
||||
*/
|
||||
static int sqliteBtreeBeginCkpt(Btree *pBt){
|
||||
static int fileBtreeBeginCkpt(Btree *pBt){
|
||||
int rc;
|
||||
if( !pBt->inTrans || pBt->inCkpt ){
|
||||
return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
|
||||
@ -966,7 +959,7 @@ static int sqliteBtreeBeginCkpt(Btree *pBt){
|
||||
** Commit a checkpoint to transaction currently in progress. If no
|
||||
** checkpoint is active, this is a no-op.
|
||||
*/
|
||||
static int sqliteBtreeCommitCkpt(Btree *pBt){
|
||||
static int fileBtreeCommitCkpt(Btree *pBt){
|
||||
int rc;
|
||||
if( pBt->inCkpt && !pBt->readOnly ){
|
||||
rc = sqlitepager_ckpt_commit(pBt->pPager);
|
||||
@ -985,7 +978,7 @@ static int sqliteBtreeCommitCkpt(Btree *pBt){
|
||||
** to use a cursor that was open at the beginning of this operation
|
||||
** will result in an error.
|
||||
*/
|
||||
static int sqliteBtreeRollbackCkpt(Btree *pBt){
|
||||
static int fileBtreeRollbackCkpt(Btree *pBt){
|
||||
int rc;
|
||||
BtCursor *pCur;
|
||||
if( pBt->inCkpt==0 || pBt->readOnly ) return SQLITE_OK;
|
||||
@ -1036,7 +1029,7 @@ static int sqliteBtreeRollbackCkpt(Btree *pBt){
|
||||
** root page of a b-tree. If it is not, then the cursor acquired
|
||||
** will not work correctly.
|
||||
*/
|
||||
static int sqliteBtreeCursor(Btree *pBt, int iTable, int wrFlag, BtCursor **ppCur){
|
||||
static int fileBtreeCursor(Btree *pBt, int iTable, int wrFlag, BtCursor **ppCur){
|
||||
int rc;
|
||||
BtCursor *pCur, *pRing;
|
||||
|
||||
@ -1097,7 +1090,7 @@ create_cursor_exception:
|
||||
** Close a cursor. The read lock on the database file is released
|
||||
** when the last cursor is closed.
|
||||
*/
|
||||
static int sqliteBtreeCloseCursor(BtCursor *pCur){
|
||||
static int fileBtreeCloseCursor(BtCursor *pCur){
|
||||
Btree *pBt = pCur->pBt;
|
||||
if( pCur->pPrev ){
|
||||
pCur->pPrev->pNext = pCur->pNext;
|
||||
@ -1150,7 +1143,7 @@ static void releaseTempCursor(BtCursor *pCur){
|
||||
** pointing to an entry (which can happen, for example, if
|
||||
** the database is empty) then *pSize is set to 0.
|
||||
*/
|
||||
static int sqliteBtreeKeySize(BtCursor *pCur, int *pSize){
|
||||
static int fileBtreeKeySize(BtCursor *pCur, int *pSize){
|
||||
Cell *pCell;
|
||||
MemPage *pPage;
|
||||
|
||||
@ -1239,7 +1232,7 @@ static int getPayload(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
** is raised. The change was made in an effort to boost performance
|
||||
** by eliminating unneeded tests.
|
||||
*/
|
||||
static int sqliteBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
static int fileBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
MemPage *pPage;
|
||||
|
||||
assert( amt>=0 );
|
||||
@ -1261,7 +1254,7 @@ static int sqliteBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
** pointing to an entry (which can happen, for example, if
|
||||
** the database is empty) then *pSize is set to 0.
|
||||
*/
|
||||
static int sqliteBtreeDataSize(BtCursor *pCur, int *pSize){
|
||||
static int fileBtreeDataSize(BtCursor *pCur, int *pSize){
|
||||
Cell *pCell;
|
||||
MemPage *pPage;
|
||||
|
||||
@ -1284,7 +1277,7 @@ static int sqliteBtreeDataSize(BtCursor *pCur, int *pSize){
|
||||
** amount requested if there are not enough bytes in the data
|
||||
** to satisfy the request.
|
||||
*/
|
||||
static int sqliteBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
static int fileBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
Cell *pCell;
|
||||
MemPage *pPage;
|
||||
|
||||
@ -1322,7 +1315,7 @@ static int sqliteBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf){
|
||||
** keys must be exactly the same length. (The length of the pCur key
|
||||
** is the actual key length minus nIgnore bytes.)
|
||||
*/
|
||||
static int sqliteBtreeKeyCompare(
|
||||
static int fileBtreeKeyCompare(
|
||||
BtCursor *pCur, /* Pointer to entry to compare against */
|
||||
const void *pKey, /* Key to compare against entry that pCur points to */
|
||||
int nKey, /* Number of bytes in pKey */
|
||||
@ -1521,7 +1514,7 @@ static int moveToRightmost(BtCursor *pCur){
|
||||
** on success. Set *pRes to 0 if the cursor actually points to something
|
||||
** or set *pRes to 1 if the table is empty.
|
||||
*/
|
||||
static int sqliteBtreeFirst(BtCursor *pCur, int *pRes){
|
||||
static int fileBtreeFirst(BtCursor *pCur, int *pRes){
|
||||
int rc;
|
||||
if( pCur->pPage==0 ) return SQLITE_ABORT;
|
||||
rc = moveToRoot(pCur);
|
||||
@ -1540,7 +1533,7 @@ static int sqliteBtreeFirst(BtCursor *pCur, int *pRes){
|
||||
** on success. Set *pRes to 0 if the cursor actually points to something
|
||||
** or set *pRes to 1 if the table is empty.
|
||||
*/
|
||||
static int sqliteBtreeLast(BtCursor *pCur, int *pRes){
|
||||
static int fileBtreeLast(BtCursor *pCur, int *pRes){
|
||||
int rc;
|
||||
if( pCur->pPage==0 ) return SQLITE_ABORT;
|
||||
rc = moveToRoot(pCur);
|
||||
@ -1579,7 +1572,8 @@ static int sqliteBtreeLast(BtCursor *pCur, int *pRes){
|
||||
** *pRes>0 The cursor is left pointing at an entry that
|
||||
** is larger than pKey.
|
||||
*/
|
||||
static int sqliteBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pRes){
|
||||
static
|
||||
int fileBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pRes){
|
||||
int rc;
|
||||
if( pCur->pPage==0 ) return SQLITE_ABORT;
|
||||
pCur->eSkip = SKIP_NONE;
|
||||
@ -1594,7 +1588,7 @@ static int sqliteBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pR
|
||||
upr = pPage->nCell-1;
|
||||
while( lwr<=upr ){
|
||||
pCur->idx = (lwr+upr)/2;
|
||||
rc = sqliteBtreeKeyCompare(pCur, pKey, nKey, 0, &c);
|
||||
rc = fileBtreeKeyCompare(pCur, pKey, nKey, 0, &c);
|
||||
if( rc ) return rc;
|
||||
if( c==0 ){
|
||||
pCur->iMatch = c;
|
||||
@ -1632,7 +1626,7 @@ static int sqliteBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pR
|
||||
** was already pointing to the last entry in the database before
|
||||
** this routine was called, then set *pRes=1.
|
||||
*/
|
||||
static int sqliteBtreeNext(BtCursor *pCur, int *pRes){
|
||||
static int fileBtreeNext(BtCursor *pCur, int *pRes){
|
||||
int rc;
|
||||
MemPage *pPage = pCur->pPage;
|
||||
assert( pRes!=0 );
|
||||
@ -1687,7 +1681,7 @@ static int sqliteBtreeNext(BtCursor *pCur, int *pRes){
|
||||
** was already pointing to the first entry in the database before
|
||||
** this routine was called, then set *pRes=1.
|
||||
*/
|
||||
static int sqliteBtreePrevious(BtCursor *pCur, int *pRes){
|
||||
static int fileBtreePrevious(BtCursor *pCur, int *pRes){
|
||||
int rc;
|
||||
Pgno pgno;
|
||||
MemPage *pPage;
|
||||
@ -2613,7 +2607,7 @@ static int checkReadLocks(BtCursor *pCur){
|
||||
** define what database the record should be inserted into. The cursor
|
||||
** is left pointing at the new record.
|
||||
*/
|
||||
static int sqliteBtreeInsert(
|
||||
static int fileBtreeInsert(
|
||||
BtCursor *pCur, /* Insert data into the table of this cursor */
|
||||
const void *pKey, int nKey, /* The key of the new record */
|
||||
const void *pData, int nData /* The data of the new record */
|
||||
@ -2639,7 +2633,7 @@ static int sqliteBtreeInsert(
|
||||
if( checkReadLocks(pCur) ){
|
||||
return SQLITE_LOCKED; /* The table pCur points to has a read lock */
|
||||
}
|
||||
rc = sqliteBtreeMoveto(pCur, pKey, nKey, &loc);
|
||||
rc = fileBtreeMoveto(pCur, pKey, nKey, &loc);
|
||||
if( rc ) return rc;
|
||||
pPage = pCur->pPage;
|
||||
assert( pPage->isInit );
|
||||
@ -2681,7 +2675,7 @@ static int sqliteBtreeInsert(
|
||||
** sqliteBtreePrevious() will always leave the cursor pointing at the
|
||||
** entry immediately before the one that was deleted.
|
||||
*/
|
||||
static int sqliteBtreeDelete(BtCursor *pCur){
|
||||
static int fileBtreeDelete(BtCursor *pCur){
|
||||
MemPage *pPage = pCur->pPage;
|
||||
Cell *pCell;
|
||||
int rc;
|
||||
@ -2724,7 +2718,7 @@ static int sqliteBtreeDelete(BtCursor *pCur){
|
||||
int szNext;
|
||||
int notUsed;
|
||||
getTempCursor(pCur, &leafCur);
|
||||
rc = sqliteBtreeNext(&leafCur, ¬Used);
|
||||
rc = fileBtreeNext(&leafCur, ¬Used);
|
||||
if( rc!=SQLITE_OK ){
|
||||
return SQLITE_CORRUPT;
|
||||
}
|
||||
@ -2764,11 +2758,12 @@ static int sqliteBtreeDelete(BtCursor *pCur){
|
||||
** number for the root page of the new table.
|
||||
**
|
||||
** In the current implementation, BTree tables and BTree indices are the
|
||||
** the same. But in the future, we may change this so that BTree tables
|
||||
** the same. In the future, we may change this so that BTree tables
|
||||
** are restricted to having a 4-byte integer key and arbitrary data and
|
||||
** BTree indices are restricted to having an arbitrary key and no data.
|
||||
** But for now, this routine also serves to create indices.
|
||||
*/
|
||||
static int sqliteBtreeCreateTable(Btree *pBt, int *piTable){
|
||||
static int fileBtreeCreateTable(Btree *pBt, int *piTable){
|
||||
MemPage *pRoot;
|
||||
Pgno pgnoRoot;
|
||||
int rc;
|
||||
@ -2788,19 +2783,6 @@ static int sqliteBtreeCreateTable(Btree *pBt, int *piTable){
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
** Create a new BTree index. Write into *piTable the page
|
||||
** number for the root page of the new index.
|
||||
**
|
||||
** In the current implementation, BTree tables and BTree indices are the
|
||||
** the same. But in the future, we may change this so that BTree tables
|
||||
** are restricted to having a 4-byte integer key and arbitrary data and
|
||||
** BTree indices are restricted to having an arbitrary key and no data.
|
||||
*/
|
||||
static int sqliteBtreeCreateIndex(Btree *pBt, int *piIndex){
|
||||
return sqliteBtreeCreateTable(pBt, piIndex);
|
||||
}
|
||||
|
||||
/*
|
||||
** Erase the given database page and all its children. Return
|
||||
** the page to the freelist.
|
||||
@ -2844,7 +2826,7 @@ static int clearDatabasePage(Btree *pBt, Pgno pgno, int freePageFlag){
|
||||
/*
|
||||
** Delete all information from a single table in the database.
|
||||
*/
|
||||
static int sqliteBtreeClearTable(Btree *pBt, int iTable){
|
||||
static int fileBtreeClearTable(Btree *pBt, int iTable){
|
||||
int rc;
|
||||
BtCursor *pCur;
|
||||
if( !pBt->inTrans ){
|
||||
@ -2858,7 +2840,7 @@ static int sqliteBtreeClearTable(Btree *pBt, int iTable){
|
||||
}
|
||||
rc = clearDatabasePage(pBt, (Pgno)iTable, 0);
|
||||
if( rc ){
|
||||
sqliteBtreeRollback(pBt);
|
||||
fileBtreeRollback(pBt);
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
@ -2868,7 +2850,7 @@ static int sqliteBtreeClearTable(Btree *pBt, int iTable){
|
||||
** the freelist. Except, the root of the principle table (the one on
|
||||
** page 2) is never added to the freelist.
|
||||
*/
|
||||
static int sqliteBtreeDropTable(Btree *pBt, int iTable){
|
||||
static int fileBtreeDropTable(Btree *pBt, int iTable){
|
||||
int rc;
|
||||
MemPage *pPage;
|
||||
BtCursor *pCur;
|
||||
@ -2882,7 +2864,7 @@ static int sqliteBtreeDropTable(Btree *pBt, int iTable){
|
||||
}
|
||||
rc = sqlitepager_get(pBt->pPager, (Pgno)iTable, (void**)&pPage);
|
||||
if( rc ) return rc;
|
||||
rc = sqliteBtreeClearTable(pBt, iTable);
|
||||
rc = fileBtreeClearTable(pBt, iTable);
|
||||
if( rc ) return rc;
|
||||
if( iTable>2 ){
|
||||
rc = freePage(pBt, pPage, iTable);
|
||||
@ -2995,7 +2977,7 @@ static int copyDatabasePage(
|
||||
/*
|
||||
** Read the meta-information out of a database file.
|
||||
*/
|
||||
static int sqliteBtreeGetMeta(Btree *pBt, int *aMeta){
|
||||
static int fileBtreeGetMeta(Btree *pBt, int *aMeta){
|
||||
PageOne *pP1;
|
||||
int rc;
|
||||
int i;
|
||||
@ -3013,7 +2995,7 @@ static int sqliteBtreeGetMeta(Btree *pBt, int *aMeta){
|
||||
/*
|
||||
** Write meta-information back into the database.
|
||||
*/
|
||||
static int sqliteBtreeUpdateMeta(Btree *pBt, int *aMeta){
|
||||
static int fileBtreeUpdateMeta(Btree *pBt, int *aMeta){
|
||||
PageOne *pP1;
|
||||
int rc, i;
|
||||
if( !pBt->inTrans ){
|
||||
@ -3039,7 +3021,7 @@ static int sqliteBtreeUpdateMeta(Btree *pBt, int *aMeta){
|
||||
** is used for debugging and testing only.
|
||||
*/
|
||||
#ifdef SQLITE_TEST
|
||||
static int sqliteBtreePageDump(Btree *pBt, int pgno, int recursive){
|
||||
static int fileBtreePageDump(Btree *pBt, int pgno, int recursive){
|
||||
int rc;
|
||||
MemPage *pPage;
|
||||
int i, j;
|
||||
@ -3100,10 +3082,10 @@ static int sqliteBtreePageDump(Btree *pBt, int pgno, int recursive){
|
||||
idx = SWAB16(pBt, pPage->u.hdr.firstCell);
|
||||
while( idx>0 && idx<SQLITE_PAGE_SIZE-MIN_CELL_SIZE ){
|
||||
Cell *pCell = (Cell*)&pPage->u.aDisk[idx];
|
||||
sqliteBtreePageDump(pBt, SWAB32(pBt, pCell->h.leftChild), 1);
|
||||
fileBtreePageDump(pBt, SWAB32(pBt, pCell->h.leftChild), 1);
|
||||
idx = SWAB16(pBt, pCell->h.iNext);
|
||||
}
|
||||
sqliteBtreePageDump(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1);
|
||||
fileBtreePageDump(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1);
|
||||
}
|
||||
sqlitepager_unref(pPage);
|
||||
return SQLITE_OK;
|
||||
@ -3126,7 +3108,7 @@ static int sqliteBtreePageDump(Btree *pBt, int pgno, int recursive){
|
||||
**
|
||||
** This routine is used for testing and debugging only.
|
||||
*/
|
||||
static int sqliteBtreeCursorDump(BtCursor *pCur, int *aResult){
|
||||
static int fileBtreeCursorDump(BtCursor *pCur, int *aResult){
|
||||
int cnt, idx;
|
||||
MemPage *pPage = pCur->pPage;
|
||||
Btree *pBt = pCur->pBt;
|
||||
@ -3158,7 +3140,7 @@ static int sqliteBtreeCursorDump(BtCursor *pCur, int *aResult){
|
||||
** Return the pager associated with a BTree. This routine is used for
|
||||
** testing and debugging only.
|
||||
*/
|
||||
static Pager *sqliteBtreePager(Btree *pBt){
|
||||
static Pager *fileBtreePager(Btree *pBt){
|
||||
return pBt->pPager;
|
||||
}
|
||||
#endif
|
||||
@ -3438,7 +3420,7 @@ static int checkTreePage(
|
||||
** and a pointer to that error message is returned. The calling function
|
||||
** is responsible for freeing the error message when it is done.
|
||||
*/
|
||||
char *sqliteBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){
|
||||
char *fileBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){
|
||||
int i;
|
||||
int nRef;
|
||||
IntegrityCk sCheck;
|
||||
@ -3502,7 +3484,7 @@ char *sqliteBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){
|
||||
/*
|
||||
** Return the full pathname of the underlying database file.
|
||||
*/
|
||||
static const char *sqliteBtreeGetFilename(Btree *pBt){
|
||||
static const char *fileBtreeGetFilename(Btree *pBt){
|
||||
assert( pBt->pPager!=0 );
|
||||
return sqlitepager_filename(pBt->pPager);
|
||||
}
|
||||
@ -3510,7 +3492,7 @@ static const char *sqliteBtreeGetFilename(Btree *pBt){
|
||||
/*
|
||||
** Change the name of the underlying database file.
|
||||
*/
|
||||
static int sqliteBtreeChangeFilename(Btree *pBt, const char *zNew){
|
||||
static int fileBtreeChangeFilename(Btree *pBt, const char *zNew){
|
||||
return sqlitepager_rename(pBt->pPager, zNew);
|
||||
}
|
||||
|
||||
@ -3521,45 +3503,45 @@ static int sqliteBtreeChangeFilename(Btree *pBt, const char *zNew){
|
||||
** to provide pointers to alternative functions in similar tables.
|
||||
*/
|
||||
static BtOps sqliteBtreeOps = {
|
||||
sqliteBtreeClose,
|
||||
sqliteBtreeSetCacheSize,
|
||||
sqliteBtreeSetSafetyLevel,
|
||||
sqliteBtreeBeginTrans,
|
||||
sqliteBtreeCommit,
|
||||
sqliteBtreeRollback,
|
||||
sqliteBtreeBeginCkpt,
|
||||
sqliteBtreeCommitCkpt,
|
||||
sqliteBtreeRollbackCkpt,
|
||||
sqliteBtreeCreateTable,
|
||||
sqliteBtreeCreateIndex,
|
||||
sqliteBtreeDropTable,
|
||||
sqliteBtreeClearTable,
|
||||
sqliteBtreeCursor,
|
||||
sqliteBtreeGetMeta,
|
||||
sqliteBtreeUpdateMeta,
|
||||
sqliteBtreeIntegrityCheck,
|
||||
sqliteBtreeGetFilename,
|
||||
sqliteBtreeChangeFilename,
|
||||
fileBtreeClose,
|
||||
fileBtreeSetCacheSize,
|
||||
fileBtreeSetSafetyLevel,
|
||||
fileBtreeBeginTrans,
|
||||
fileBtreeCommit,
|
||||
fileBtreeRollback,
|
||||
fileBtreeBeginCkpt,
|
||||
fileBtreeCommitCkpt,
|
||||
fileBtreeRollbackCkpt,
|
||||
fileBtreeCreateTable,
|
||||
fileBtreeCreateTable, /* Really sqliteBtreeCreateIndex() */
|
||||
fileBtreeDropTable,
|
||||
fileBtreeClearTable,
|
||||
fileBtreeCursor,
|
||||
fileBtreeGetMeta,
|
||||
fileBtreeUpdateMeta,
|
||||
fileBtreeIntegrityCheck,
|
||||
fileBtreeGetFilename,
|
||||
fileBtreeChangeFilename,
|
||||
#ifdef SQLITE_TEST
|
||||
sqliteBtreePageDump,
|
||||
sqliteBtreePager
|
||||
fileBtreePageDump,
|
||||
fileBtreePager
|
||||
#endif
|
||||
};
|
||||
static BtCursorOps sqliteBtreeCursorOps = {
|
||||
sqliteBtreeMoveto,
|
||||
sqliteBtreeDelete,
|
||||
sqliteBtreeInsert,
|
||||
sqliteBtreeFirst,
|
||||
sqliteBtreeLast,
|
||||
sqliteBtreeNext,
|
||||
sqliteBtreePrevious,
|
||||
sqliteBtreeKeySize,
|
||||
sqliteBtreeKey,
|
||||
sqliteBtreeKeyCompare,
|
||||
sqliteBtreeDataSize,
|
||||
sqliteBtreeData,
|
||||
sqliteBtreeCloseCursor,
|
||||
fileBtreeMoveto,
|
||||
fileBtreeDelete,
|
||||
fileBtreeInsert,
|
||||
fileBtreeFirst,
|
||||
fileBtreeLast,
|
||||
fileBtreeNext,
|
||||
fileBtreePrevious,
|
||||
fileBtreeKeySize,
|
||||
fileBtreeKey,
|
||||
fileBtreeKeyCompare,
|
||||
fileBtreeDataSize,
|
||||
fileBtreeData,
|
||||
fileBtreeCloseCursor,
|
||||
#ifdef SQLITE_TEST
|
||||
sqliteBtreeCursorDump,
|
||||
fileBtreeCursorDump,
|
||||
#endif
|
||||
};
|
||||
|
||||
10
src/btree.h
10
src/btree.h
@ -13,7 +13,7 @@
|
||||
** subsystem. See comments in the source code for a detailed description
|
||||
** of what each interface routine does.
|
||||
**
|
||||
** @(#) $Id: btree.h,v 1.30 2003/04/06 20:44:45 drh Exp $
|
||||
** @(#) $Id: btree.h,v 1.31 2003/04/16 01:28:16 drh Exp $
|
||||
*/
|
||||
#ifndef _BTREE_H_
|
||||
#define _BTREE_H_
|
||||
@ -96,7 +96,6 @@ struct BtCursorOps {
|
||||
|
||||
int sqliteBtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree);
|
||||
|
||||
#if !defined(SQLITE_NO_BTREE_DEFS)
|
||||
#define btOps(pBt) (*((BtOps **)(pBt)))
|
||||
#define btCOps(pCur) (*((BtCursorOps **)(pCur)))
|
||||
|
||||
@ -143,18 +142,15 @@ int sqliteBtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree);
|
||||
#define sqliteBtreeGetFilename(pBt) (btOps(pBt)->GetFilename(pBt))
|
||||
#define sqliteBtreeChangeFilename(pBt, zNew)\
|
||||
(btOps(pBt)->ChangeFilename(pBt, zNew))
|
||||
#endif
|
||||
|
||||
#ifdef SQLITE_TEST
|
||||
#if !defined(SQLITE_NO_BTREE_DEFS)
|
||||
#define sqliteBtreePageDump(pBt, pgno, recursive)\
|
||||
(btOps(pBt)->PageDump(pBt, pgno, recursive))
|
||||
#define sqliteBtreeCursorDump(pCur, aResult)\
|
||||
(btCOps(pCur)->CursorDump(pCur, aResult))
|
||||
#define sqliteBtreePager(pBt) (btOps(pBt)->Pager(pBt))
|
||||
#endif
|
||||
|
||||
int btree_native_byte_order;
|
||||
#endif
|
||||
#endif /* SQLITE_TEST */
|
||||
|
||||
|
||||
#endif /* _BTREE_H_ */
|
||||
|
||||
183
src/btree_rb.c
183
src/btree_rb.c
@ -9,14 +9,13 @@
|
||||
** May you share freely, never taking more than you give.
|
||||
**
|
||||
*************************************************************************
|
||||
** $Id: btree_rb.c,v 1.2 2003/04/15 19:22:23 drh Exp $
|
||||
** $Id: btree_rb.c,v 1.3 2003/04/16 01:28:16 drh Exp $
|
||||
**
|
||||
** This file implements an in-core database using Red-Black balanced
|
||||
** binary trees.
|
||||
**
|
||||
** It was contributed to SQLite by anonymous on 2003-Feb-04 23:24:49 UTC.
|
||||
*/
|
||||
#define SQLITE_NO_BTREE_DEFS
|
||||
#include "btree.h"
|
||||
#include "sqliteInt.h"
|
||||
#include <assert.h>
|
||||
@ -127,11 +126,11 @@ struct BtRbNode {
|
||||
};
|
||||
|
||||
/* Forward declarations */
|
||||
static int sqliteBtreeMoveto(BtCursor* pCur, const void *pKey, int nKey, int *pRes);
|
||||
static int sqliteBtreeClearTable(Btree* tree, int n);
|
||||
static int sqliteBtreeNext(BtCursor* pCur, int *pRes);
|
||||
static int sqliteBtreeLast(BtCursor* pCur, int *pRes);
|
||||
static int sqliteBtreePrevious(BtCursor* pCur, int *pRes);
|
||||
static int memBtreeMoveto(BtCursor* pCur, const void *pKey, int nKey,int *pRes);
|
||||
static int memBtreeClearTable(Btree* tree, int n);
|
||||
static int memBtreeNext(BtCursor* pCur, int *pRes);
|
||||
static int memBtreeLast(BtCursor* pCur, int *pRes);
|
||||
static int memBtreePrevious(BtCursor* pCur, int *pRes);
|
||||
|
||||
/*
|
||||
* The key-compare function for the red-black trees. Returns as follows:
|
||||
@ -593,7 +592,7 @@ int sqliteRBtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree)
|
||||
* Create a new table in the supplied Btree. Set *n to the new table number.
|
||||
* Return SQLITE_OK if the operation is a success.
|
||||
*/
|
||||
static int sqliteBtreeCreateTable(Btree* tree, int* n)
|
||||
static int memBtreeCreateTable(Btree* tree, int* n)
|
||||
{
|
||||
assert( tree->eTransState != TRANS_NONE );
|
||||
|
||||
@ -612,25 +611,15 @@ static int sqliteBtreeCreateTable(Btree* tree, int* n)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is currently an alias for sqliteBtreeCreateTable(). There is a note in
|
||||
* btree.c suggesting that one day indices and tables may be optimized
|
||||
* differently.
|
||||
*/
|
||||
static int sqliteBtreeCreateIndex(Btree* tree, int* n)
|
||||
{
|
||||
return sqliteBtreeCreateTable(tree, n);
|
||||
}
|
||||
|
||||
/*
|
||||
* Delete table n from the supplied Btree.
|
||||
*/
|
||||
static int sqliteBtreeDropTable(Btree* tree, int n)
|
||||
static int memBtreeDropTable(Btree* tree, int n)
|
||||
{
|
||||
BtRbTree *pTree;
|
||||
assert( tree->eTransState != TRANS_NONE );
|
||||
|
||||
sqliteBtreeClearTable(tree, n);
|
||||
memBtreeClearTable(tree, n);
|
||||
pTree = sqliteHashFind(&tree->tblHash, 0, n);
|
||||
assert(pTree);
|
||||
sqliteFree(pTree);
|
||||
@ -646,7 +635,7 @@ static int sqliteBtreeDropTable(Btree* tree, int n)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeKeyCompare(BtCursor* pCur, const void *pKey, int nKey,
|
||||
static int memBtreeKeyCompare(BtCursor* pCur, const void *pKey, int nKey,
|
||||
int nIgnore, int *pRes)
|
||||
{
|
||||
assert(pCur);
|
||||
@ -670,7 +659,7 @@ static int sqliteBtreeKeyCompare(BtCursor* pCur, const void *pKey, int nKey,
|
||||
*
|
||||
* Note that BtCursor.eSkip and BtCursor.pNode both initialize to 0.
|
||||
*/
|
||||
static int sqliteBtreeCursor(Btree* tree, int iTable, int wrFlag, BtCursor **ppCur)
|
||||
static int memBtreeCursor(Btree* tree, int iTable, int wrFlag, BtCursor **ppCur)
|
||||
{
|
||||
assert(tree);
|
||||
*ppCur = sqliteMalloc(sizeof(BtCursor));
|
||||
@ -691,7 +680,7 @@ static int sqliteBtreeCursor(Btree* tree, int iTable, int wrFlag, BtCursor **ppC
|
||||
*
|
||||
* If the key exists already in the tree, just replace the data.
|
||||
*/
|
||||
static int sqliteBtreeInsert(BtCursor* pCur, const void *pKey, int nKey,
|
||||
static int memBtreeInsert(BtCursor* pCur, const void *pKey, int nKey,
|
||||
const void *pDataInput, int nData)
|
||||
{
|
||||
void * pData;
|
||||
@ -716,7 +705,7 @@ static int sqliteBtreeInsert(BtCursor* pCur, const void *pKey, int nKey,
|
||||
*
|
||||
* The new node is initially red.
|
||||
*/
|
||||
sqliteBtreeMoveto( pCur, pKey, nKey, &match);
|
||||
memBtreeMoveto( pCur, pKey, nKey, &match);
|
||||
if( match ){
|
||||
BtRbNode *pNode = sqliteMalloc(sizeof(BtRbNode));
|
||||
pNode->nKey = nKey;
|
||||
@ -800,7 +789,7 @@ static int sqliteBtreeInsert(BtCursor* pCur, const void *pKey, int nKey,
|
||||
** *pRes>0 The cursor is left pointing at an entry that
|
||||
** is larger than pKey.
|
||||
*/
|
||||
static int sqliteBtreeMoveto(BtCursor* pCur, const void *pKey, int nKey, int *pRes)
|
||||
static int memBtreeMoveto(BtCursor* pCur, const void *pKey, int nKey, int *pRes)
|
||||
{
|
||||
BtRbNode *pTmp = 0;
|
||||
|
||||
@ -844,7 +833,7 @@ static int sqliteBtreeMoveto(BtCursor* pCur, const void *pKey, int nKey, int *pR
|
||||
** sqliteBtreePrevious() will always leave the cursor pointing at the
|
||||
** entry immediately before the one that was deleted.
|
||||
*/
|
||||
static int sqliteBtreeDelete(BtCursor* pCur)
|
||||
static int memBtreeDelete(BtCursor* pCur)
|
||||
{
|
||||
BtRbNode *pZ; /* The one being deleted */
|
||||
BtRbNode *pChild; /* The child of the spliced out node */
|
||||
@ -880,7 +869,7 @@ static int sqliteBtreeDelete(BtCursor* pCur)
|
||||
BtRbNode *pTmp;
|
||||
int dummy;
|
||||
pCur->eSkip = SKIP_NONE;
|
||||
sqliteBtreeNext(pCur, &dummy);
|
||||
memBtreeNext(pCur, &dummy);
|
||||
assert( dummy == 0 );
|
||||
if( pCur->pBtree->eTransState == TRANS_ROLLBACK ){
|
||||
sqliteFree(pZ->pKey);
|
||||
@ -897,11 +886,11 @@ static int sqliteBtreeDelete(BtCursor* pCur)
|
||||
}else{
|
||||
int res;
|
||||
pCur->eSkip = SKIP_NONE;
|
||||
sqliteBtreeNext(pCur, &res);
|
||||
memBtreeNext(pCur, &res);
|
||||
pCur->eSkip = SKIP_NEXT;
|
||||
if( res ){
|
||||
sqliteBtreeLast(pCur, &res);
|
||||
sqliteBtreePrevious(pCur, &res);
|
||||
memBtreeLast(pCur, &res);
|
||||
memBtreePrevious(pCur, &res);
|
||||
pCur->eSkip = SKIP_PREV;
|
||||
}
|
||||
if( pCur->pBtree->eTransState == TRANS_ROLLBACK ){
|
||||
@ -943,7 +932,7 @@ static int sqliteBtreeDelete(BtCursor* pCur)
|
||||
/*
|
||||
* Empty table n of the Btree.
|
||||
*/
|
||||
static int sqliteBtreeClearTable(Btree* tree, int n)
|
||||
static int memBtreeClearTable(Btree* tree, int n)
|
||||
{
|
||||
BtRbTree *pTree;
|
||||
BtRbNode *pNode;
|
||||
@ -987,7 +976,7 @@ static int sqliteBtreeClearTable(Btree* tree, int n)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeFirst(BtCursor* pCur, int *pRes)
|
||||
static int memBtreeFirst(BtCursor* pCur, int *pRes)
|
||||
{
|
||||
if( pCur->pTree->pHead ){
|
||||
pCur->pNode = pCur->pTree->pHead;
|
||||
@ -1004,7 +993,7 @@ static int sqliteBtreeFirst(BtCursor* pCur, int *pRes)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeLast(BtCursor* pCur, int *pRes)
|
||||
static int memBtreeLast(BtCursor* pCur, int *pRes)
|
||||
{
|
||||
if( pCur->pTree->pHead ){
|
||||
pCur->pNode = pCur->pTree->pHead;
|
||||
@ -1021,7 +1010,7 @@ static int sqliteBtreeLast(BtCursor* pCur, int *pRes)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeNext(BtCursor* pCur, int *pRes)
|
||||
static int memBtreeNext(BtCursor* pCur, int *pRes)
|
||||
{
|
||||
if( pCur->pNode && pCur->eSkip != SKIP_NEXT ){
|
||||
if( pCur->pNode->pRight ){
|
||||
@ -1048,7 +1037,7 @@ static int sqliteBtreeNext(BtCursor* pCur, int *pRes)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreePrevious(BtCursor* pCur, int *pRes)
|
||||
static int memBtreePrevious(BtCursor* pCur, int *pRes)
|
||||
{
|
||||
if( pCur->pNode && pCur->eSkip != SKIP_PREV ){
|
||||
if( pCur->pNode->pLeft ){
|
||||
@ -1075,7 +1064,7 @@ static int sqliteBtreePrevious(BtCursor* pCur, int *pRes)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeKeySize(BtCursor* pCur, int *pSize)
|
||||
static int memBtreeKeySize(BtCursor* pCur, int *pSize)
|
||||
{
|
||||
if( pCur->pNode ){
|
||||
*pSize = pCur->pNode->nKey;
|
||||
@ -1085,7 +1074,7 @@ static int sqliteBtreeKeySize(BtCursor* pCur, int *pSize)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeKey(BtCursor* pCur, int offset, int amt, char *zBuf)
|
||||
static int memBtreeKey(BtCursor* pCur, int offset, int amt, char *zBuf)
|
||||
{
|
||||
if( !pCur->pNode ) return 0;
|
||||
if( !pCur->pNode->pKey || ((amt + offset) <= pCur->pNode->nKey) ){
|
||||
@ -1098,7 +1087,7 @@ static int sqliteBtreeKey(BtCursor* pCur, int offset, int amt, char *zBuf)
|
||||
assert(0);
|
||||
}
|
||||
|
||||
static int sqliteBtreeDataSize(BtCursor* pCur, int *pSize)
|
||||
static int memBtreeDataSize(BtCursor* pCur, int *pSize)
|
||||
{
|
||||
if( pCur->pNode ){
|
||||
*pSize = pCur->pNode->nData;
|
||||
@ -1108,7 +1097,7 @@ static int sqliteBtreeDataSize(BtCursor* pCur, int *pSize)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf)
|
||||
static int memBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf)
|
||||
{
|
||||
if( !pCur->pNode ) return 0;
|
||||
if( (amt + offset) <= pCur->pNode->nData ){
|
||||
@ -1121,19 +1110,19 @@ static int sqliteBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf)
|
||||
assert(0);
|
||||
}
|
||||
|
||||
static int sqliteBtreeCloseCursor(BtCursor* pCur)
|
||||
static int memBtreeCloseCursor(BtCursor* pCur)
|
||||
{
|
||||
sqliteFree(pCur);
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeGetMeta(Btree* tree, int* aMeta)
|
||||
static int memBtreeGetMeta(Btree* tree, int* aMeta)
|
||||
{
|
||||
memcpy( aMeta, tree->aMetaData, sizeof(int) * SQLITE_N_BTREE_META );
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeUpdateMeta(Btree* tree, int* aMeta)
|
||||
static int memBtreeUpdateMeta(Btree* tree, int* aMeta)
|
||||
{
|
||||
memcpy( tree->aMetaData, aMeta, sizeof(int) * SQLITE_N_BTREE_META );
|
||||
return SQLITE_OK;
|
||||
@ -1144,7 +1133,7 @@ static int sqliteBtreeUpdateMeta(Btree* tree, int* aMeta)
|
||||
* binary tree. If an error is found, return an explanation of the problem in
|
||||
* memory obtained from sqliteMalloc(). Parameters aRoot and nRoot are ignored.
|
||||
*/
|
||||
static char *sqliteBtreeIntegrityCheck(Btree* tree, int* aRoot, int nRoot)
|
||||
static char *memBtreeIntegrityCheck(Btree* tree, int* aRoot, int nRoot)
|
||||
{
|
||||
char * msg = 0;
|
||||
HashElem *p;
|
||||
@ -1160,28 +1149,28 @@ static char *sqliteBtreeIntegrityCheck(Btree* tree, int* aRoot, int nRoot)
|
||||
/*
|
||||
* Close the supplied Btree. Delete everything associated with it.
|
||||
*/
|
||||
static int sqliteBtreeClose(Btree* tree)
|
||||
static int memBtreeClose(Btree* tree)
|
||||
{
|
||||
HashElem *p;
|
||||
for(p=sqliteHashFirst(&tree->tblHash); p; p=sqliteHashNext(p)){
|
||||
tree->eTransState = TRANS_ROLLBACK;
|
||||
sqliteBtreeClearTable(tree, sqliteHashKeysize(p));
|
||||
memBtreeClearTable(tree, sqliteHashKeysize(p));
|
||||
sqliteFree(sqliteHashData(p));
|
||||
}
|
||||
sqliteFree(tree);
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeSetCacheSize(Btree* tree, int sz)
|
||||
static int memBtreeSetCacheSize(Btree* tree, int sz)
|
||||
{
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeSetSafetyLevel(Btree *pBt, int level){
|
||||
static int memBtreeSetSafetyLevel(Btree *pBt, int level){
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeBeginTrans(Btree* tree)
|
||||
static int memBtreeBeginTrans(Btree* tree)
|
||||
{
|
||||
if( tree->eTransState != TRANS_NONE )
|
||||
return SQLITE_ERROR;
|
||||
@ -1191,7 +1180,7 @@ static int sqliteBtreeBeginTrans(Btree* tree)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeCommit(Btree* tree)
|
||||
static int memBtreeCommit(Btree* tree)
|
||||
{
|
||||
/* Just delete pTransRollback and pCheckRollback */
|
||||
BtRollbackOp *pOp, *pTmp;
|
||||
@ -1235,7 +1224,7 @@ static void execute_rollback_list(Btree *pBtree, BtRollbackOp *pList)
|
||||
assert(cur.pTree);
|
||||
cur.iTree = pList->iTab;
|
||||
cur.eSkip = SKIP_NONE;
|
||||
sqliteBtreeInsert( &cur, pList->pKey,
|
||||
memBtreeInsert( &cur, pList->pKey,
|
||||
pList->nKey, pList->pData, pList->nData );
|
||||
break;
|
||||
case ROLLBACK_DELETE:
|
||||
@ -1243,15 +1232,15 @@ static void execute_rollback_list(Btree *pBtree, BtRollbackOp *pList)
|
||||
assert(cur.pTree);
|
||||
cur.iTree = pList->iTab;
|
||||
cur.eSkip = SKIP_NONE;
|
||||
sqliteBtreeMoveto(&cur, pList->pKey, pList->nKey, &res);
|
||||
memBtreeMoveto(&cur, pList->pKey, pList->nKey, &res);
|
||||
assert(res == 0);
|
||||
sqliteBtreeDelete( &cur );
|
||||
memBtreeDelete( &cur );
|
||||
break;
|
||||
case ROLLBACK_CREATE:
|
||||
btreeCreateTable(pBtree, pList->iTab);
|
||||
break;
|
||||
case ROLLBACK_DROP:
|
||||
sqliteBtreeDropTable(pBtree, pList->iTab);
|
||||
memBtreeDropTable(pBtree, pList->iTab);
|
||||
break;
|
||||
default:
|
||||
assert(0);
|
||||
@ -1264,7 +1253,7 @@ static void execute_rollback_list(Btree *pBtree, BtRollbackOp *pList)
|
||||
}
|
||||
}
|
||||
|
||||
static int sqliteBtreeRollback(Btree* tree)
|
||||
static int memBtreeRollback(Btree* tree)
|
||||
{
|
||||
tree->eTransState = TRANS_ROLLBACK;
|
||||
execute_rollback_list(tree, tree->pCheckRollback);
|
||||
@ -1276,7 +1265,7 @@ static int sqliteBtreeRollback(Btree* tree)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeBeginCkpt(Btree* tree)
|
||||
static int memBtreeBeginCkpt(Btree* tree)
|
||||
{
|
||||
if( tree->eTransState != TRANS_INTRANSACTION )
|
||||
return SQLITE_ERROR;
|
||||
@ -1287,7 +1276,7 @@ static int sqliteBtreeBeginCkpt(Btree* tree)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeCommitCkpt(Btree* tree)
|
||||
static int memBtreeCommitCkpt(Btree* tree)
|
||||
{
|
||||
if( tree->eTransState == TRANS_INCHECKPOINT ){
|
||||
if( tree->pCheckRollback ){
|
||||
@ -1301,7 +1290,7 @@ static int sqliteBtreeCommitCkpt(Btree* tree)
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeRollbackCkpt(Btree* tree)
|
||||
static int memBtreeRollbackCkpt(Btree* tree)
|
||||
{
|
||||
if( tree->eTransState != TRANS_INCHECKPOINT ) return SQLITE_OK;
|
||||
tree->eTransState = TRANS_ROLLBACK;
|
||||
@ -1314,19 +1303,19 @@ static int sqliteBtreeRollbackCkpt(Btree* tree)
|
||||
}
|
||||
|
||||
#ifdef SQLITE_TEST
|
||||
static int sqliteBtreePageDump(Btree* tree, int pgno, int rec)
|
||||
static int memBtreePageDump(Btree* tree, int pgno, int rec)
|
||||
{
|
||||
assert(!"Cannot call sqliteBtreePageDump");
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static int sqliteBtreeCursorDump(BtCursor* pCur, int* aRes)
|
||||
static int memBtreeCursorDump(BtCursor* pCur, int* aRes)
|
||||
{
|
||||
assert(!"Cannot call sqliteBtreeCursorDump");
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static struct Pager *sqliteBtreePager(Btree* tree)
|
||||
static struct Pager *memBtreePager(Btree* tree)
|
||||
{
|
||||
assert(!"Cannot call sqliteBtreePager");
|
||||
return SQLITE_OK;
|
||||
@ -1336,60 +1325,60 @@ static struct Pager *sqliteBtreePager(Btree* tree)
|
||||
/*
|
||||
** Return the full pathname of the underlying database file.
|
||||
*/
|
||||
static const char *sqliteBtreeGetFilename(Btree *pBt){
|
||||
static const char *memBtreeGetFilename(Btree *pBt){
|
||||
return ":memory:";
|
||||
}
|
||||
|
||||
/*
|
||||
** Change the name of the underlying database file.
|
||||
*/
|
||||
static int sqliteBtreeChangeFilename(Btree *pBt, const char *zNew){
|
||||
static int memBtreeChangeFilename(Btree *pBt, const char *zNew){
|
||||
return SQLITE_OK;
|
||||
}
|
||||
|
||||
static BtOps sqliteBtreeOps = {
|
||||
sqliteBtreeClose,
|
||||
sqliteBtreeSetCacheSize,
|
||||
sqliteBtreeSetSafetyLevel,
|
||||
sqliteBtreeBeginTrans,
|
||||
sqliteBtreeCommit,
|
||||
sqliteBtreeRollback,
|
||||
sqliteBtreeBeginCkpt,
|
||||
sqliteBtreeCommitCkpt,
|
||||
sqliteBtreeRollbackCkpt,
|
||||
sqliteBtreeCreateTable,
|
||||
sqliteBtreeCreateIndex,
|
||||
sqliteBtreeDropTable,
|
||||
sqliteBtreeClearTable,
|
||||
sqliteBtreeCursor,
|
||||
sqliteBtreeGetMeta,
|
||||
sqliteBtreeUpdateMeta,
|
||||
sqliteBtreeIntegrityCheck,
|
||||
sqliteBtreeGetFilename,
|
||||
sqliteBtreeChangeFilename,
|
||||
memBtreeClose,
|
||||
memBtreeSetCacheSize,
|
||||
memBtreeSetSafetyLevel,
|
||||
memBtreeBeginTrans,
|
||||
memBtreeCommit,
|
||||
memBtreeRollback,
|
||||
memBtreeBeginCkpt,
|
||||
memBtreeCommitCkpt,
|
||||
memBtreeRollbackCkpt,
|
||||
memBtreeCreateTable,
|
||||
memBtreeCreateTable,
|
||||
memBtreeDropTable,
|
||||
memBtreeClearTable,
|
||||
memBtreeCursor,
|
||||
memBtreeGetMeta,
|
||||
memBtreeUpdateMeta,
|
||||
memBtreeIntegrityCheck,
|
||||
memBtreeGetFilename,
|
||||
memBtreeChangeFilename,
|
||||
|
||||
#ifdef SQLITE_TEST
|
||||
sqliteBtreePageDump,
|
||||
sqliteBtreePager
|
||||
memBtreePageDump,
|
||||
memBtreePager
|
||||
#endif
|
||||
};
|
||||
|
||||
static BtCursorOps sqliteBtreeCursorOps = {
|
||||
sqliteBtreeMoveto,
|
||||
sqliteBtreeDelete,
|
||||
sqliteBtreeInsert,
|
||||
sqliteBtreeFirst,
|
||||
sqliteBtreeLast,
|
||||
sqliteBtreeNext,
|
||||
sqliteBtreePrevious,
|
||||
sqliteBtreeKeySize,
|
||||
sqliteBtreeKey,
|
||||
sqliteBtreeKeyCompare,
|
||||
sqliteBtreeDataSize,
|
||||
sqliteBtreeData,
|
||||
sqliteBtreeCloseCursor,
|
||||
memBtreeMoveto,
|
||||
memBtreeDelete,
|
||||
memBtreeInsert,
|
||||
memBtreeFirst,
|
||||
memBtreeLast,
|
||||
memBtreeNext,
|
||||
memBtreePrevious,
|
||||
memBtreeKeySize,
|
||||
memBtreeKey,
|
||||
memBtreeKeyCompare,
|
||||
memBtreeDataSize,
|
||||
memBtreeData,
|
||||
memBtreeCloseCursor,
|
||||
#ifdef SQLITE_TEST
|
||||
sqliteBtreeCursorDump,
|
||||
memBtreeCursorDump,
|
||||
#endif
|
||||
|
||||
};
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
** other files are for internal use by SQLite and should not be
|
||||
** accessed by users of the library.
|
||||
**
|
||||
** $Id: main.c,v 1.123 2003/04/15 01:19:48 drh Exp $
|
||||
** $Id: main.c,v 1.124 2003/04/16 01:28:16 drh Exp $
|
||||
*/
|
||||
#include "sqliteInt.h"
|
||||
#include "os.h"
|
||||
@ -426,7 +426,7 @@ sqlite *sqlite_open(const char *zFilename, int mode, char **pzErrMsg){
|
||||
}
|
||||
|
||||
/* Open the backend database driver */
|
||||
rc = sqliteBtreeOpen(zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);
|
||||
rc = sqliteBtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);
|
||||
if( rc!=SQLITE_OK ){
|
||||
switch( rc ){
|
||||
default: {
|
||||
@ -1065,8 +1065,6 @@ void *sqlite_commit_hook(
|
||||
** is for temporary use only and is deleted as soon as the connection
|
||||
** is closed.
|
||||
**
|
||||
**
|
||||
**
|
||||
** A temporary database can be either a disk file (that is automatically
|
||||
** deleted when the file is closed) or a set of red-black trees held in memory,
|
||||
** depending on the values of the TEMP_STORE compile-time macro and the
|
||||
|
||||
Reference in New Issue
Block a user