Symaptic: os/persistentdata/persistentstorage/sql/SQLite364/btree.c@260cb5ec6c19 (annotated)

sl@0	1	/*
sl@0	2	** 2004 April 6
sl@0	3	**
sl@0	4	** The author disclaims copyright to this source code. In place of
sl@0	5	** a legal notice, here is a blessing:
sl@0	6	**
sl@0	7	** May you do good and not evil.
sl@0	8	** May you find forgiveness for yourself and forgive others.
sl@0	9	** May you share freely, never taking more than you give.
sl@0	10	**
sl@0	11	*************************************************************************
sl@0	12	** $Id: btree.c,v 1.525 2008/10/08 17:58:49 danielk1977 Exp $
sl@0	13	**
sl@0	14	** This file implements a external (disk-based) database using BTrees.
sl@0	15	** See the header comment on "btreeInt.h" for additional information.
sl@0	16	** Including a description of file format and an overview of operation.
sl@0	17	*/
sl@0	18	#include "btreeInt.h"
sl@0	19
sl@0	20	/*
sl@0	21	** The header string that appears at the beginning of every
sl@0	22	** SQLite database.
sl@0	23	*/
sl@0	24	static const char zMagicHeader[] = SQLITE_FILE_HEADER;
sl@0	25
sl@0	26	/*
sl@0	27	** Set this global variable to 1 to enable tracing using the TRACE
sl@0	28	** macro.
sl@0	29	*/
sl@0	30	#if 0
sl@0	31	int sqlite3BtreeTrace=0; /* True to enable tracing */
sl@0	32	# define TRACE(X) if(sqlite3BtreeTrace){printf X;fflush(stdout);}
sl@0	33	#else
sl@0	34	# define TRACE(X)
sl@0	35	#endif
sl@0	36
sl@0	37	/*
sl@0	38	** Sometimes we need a small amount of code such as a variable initialization
sl@0	39	** to setup for a later assert() statement. We do not want this code to
sl@0	40	** appear when assert() is disabled. The following macro is therefore
sl@0	41	** used to contain that setup code. The "VVA" acronym stands for
sl@0	42	** "Verification, Validation, and Accreditation". In other words, the
sl@0	43	** code within VVA_ONLY() will only run during verification processes.
sl@0	44	*/
sl@0	45	#ifndef NDEBUG
sl@0	46	# define VVA_ONLY(X) X
sl@0	47	#else
sl@0	48	# define VVA_ONLY(X)
sl@0	49	#endif
sl@0	50
sl@0	51
sl@0	52
sl@0	53	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	54	/*
sl@0	55	** A list of BtShared objects that are eligible for participation
sl@0	56	** in shared cache. This variable has file scope during normal builds,
sl@0	57	** but the test harness needs to access it so we make it global for
sl@0	58	** test builds.
sl@0	59	*/
sl@0	60	#ifdef SQLITE_TEST
sl@0	61	BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
sl@0	62	#else
sl@0	63	static BtShared *SQLITE_WSD sqlite3SharedCacheList = 0;
sl@0	64	#endif
sl@0	65	#endif /* SQLITE_OMIT_SHARED_CACHE */
sl@0	66
sl@0	67	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	68	/*
sl@0	69	** Enable or disable the shared pager and schema features.
sl@0	70	**
sl@0	71	** This routine has no effect on existing database connections.
sl@0	72	** The shared cache setting effects only future calls to
sl@0	73	** sqlite3_open(), sqlite3_open16(), or sqlite3_open_v2().
sl@0	74	*/
sl@0	75	int sqlite3_enable_shared_cache(int enable){
sl@0	76	sqlite3GlobalConfig.sharedCacheEnabled = enable;
sl@0	77	return SQLITE_OK;
sl@0	78	}
sl@0	79	#endif
sl@0	80
sl@0	81
sl@0	82	/*
sl@0	83	** Forward declaration
sl@0	84	*/
sl@0	85	static int checkReadLocks(Btree, Pgno, BtCursor, i64);
sl@0	86
sl@0	87
sl@0	88	#ifdef SQLITE_OMIT_SHARED_CACHE
sl@0	89	/*
sl@0	90	** The functions queryTableLock(), lockTable() and unlockAllTables()
sl@0	91	** manipulate entries in the BtShared.pLock linked list used to store
sl@0	92	** shared-cache table level locks. If the library is compiled with the
sl@0	93	** shared-cache feature disabled, then there is only ever one user
sl@0	94	** of each BtShared structure and so this locking is not necessary.
sl@0	95	** So define the lock related functions as no-ops.
sl@0	96	*/
sl@0	97	#define queryTableLock(a,b,c) SQLITE_OK
sl@0	98	#define lockTable(a,b,c) SQLITE_OK
sl@0	99	#define unlockAllTables(a)
sl@0	100	#endif
sl@0	101
sl@0	102	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	103	/*
sl@0	104	** Query to see if btree handle p may obtain a lock of type eLock
sl@0	105	** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
sl@0	106	** SQLITE_OK if the lock may be obtained (by calling lockTable()), or
sl@0	107	** SQLITE_LOCKED if not.
sl@0	108	*/
sl@0	109	static int queryTableLock(Btree *p, Pgno iTab, u8 eLock){
sl@0	110	BtShared *pBt = p->pBt;
sl@0	111	BtLock *pIter;
sl@0	112
sl@0	113	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	114	assert( eLock==READ_LOCK \|\| eLock==WRITE_LOCK );
sl@0	115	assert( p->db!=0 );
sl@0	116
sl@0	117	/* This is a no-op if the shared-cache is not enabled */
sl@0	118	if( !p->sharable ){
sl@0	119	return SQLITE_OK;
sl@0	120	}
sl@0	121
sl@0	122	/* If some other connection is holding an exclusive lock, the
sl@0	123	** requested lock may not be obtained.
sl@0	124	*/
sl@0	125	if( pBt->pExclusive && pBt->pExclusive!=p ){
sl@0	126	return SQLITE_LOCKED;
sl@0	127	}
sl@0	128
sl@0	129	/* This (along with lockTable()) is where the ReadUncommitted flag is
sl@0	130	** dealt with. If the caller is querying for a read-lock and the flag is
sl@0	131	** set, it is unconditionally granted - even if there are write-locks
sl@0	132	** on the table. If a write-lock is requested, the ReadUncommitted flag
sl@0	133	** is not considered.
sl@0	134	**
sl@0	135	** In function lockTable(), if a read-lock is demanded and the
sl@0	136	** ReadUncommitted flag is set, no entry is added to the locks list
sl@0	137	** (BtShared.pLock).
sl@0	138	**
sl@0	139	** To summarize: If the ReadUncommitted flag is set, then read cursors do
sl@0	140	** not create or respect table locks. The locking procedure for a
sl@0	141	** write-cursor does not change.
sl@0	142	*/
sl@0	143	if(
sl@0	144	0==(p->db->flags&SQLITE_ReadUncommitted) \|\|
sl@0	145	eLock==WRITE_LOCK \|\|
sl@0	146	iTab==MASTER_ROOT
sl@0	147	){
sl@0	148	for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
sl@0	149	if( pIter->pBtree!=p && pIter->iTable==iTab &&
sl@0	150	(pIter->eLock!=eLock \|\| eLock!=READ_LOCK) ){
sl@0	151	return SQLITE_LOCKED;
sl@0	152	}
sl@0	153	}
sl@0	154	}
sl@0	155	return SQLITE_OK;
sl@0	156	}
sl@0	157	#endif /* !SQLITE_OMIT_SHARED_CACHE */
sl@0	158
sl@0	159	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	160	/*
sl@0	161	** Add a lock on the table with root-page iTable to the shared-btree used
sl@0	162	** by Btree handle p. Parameter eLock must be either READ_LOCK or
sl@0	163	** WRITE_LOCK.
sl@0	164	**
sl@0	165	** SQLITE_OK is returned if the lock is added successfully. SQLITE_BUSY and
sl@0	166	** SQLITE_NOMEM may also be returned.
sl@0	167	*/
sl@0	168	static int lockTable(Btree *p, Pgno iTable, u8 eLock){
sl@0	169	BtShared *pBt = p->pBt;
sl@0	170	BtLock *pLock = 0;
sl@0	171	BtLock *pIter;
sl@0	172
sl@0	173	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	174	assert( eLock==READ_LOCK \|\| eLock==WRITE_LOCK );
sl@0	175	assert( p->db!=0 );
sl@0	176
sl@0	177	/* This is a no-op if the shared-cache is not enabled */
sl@0	178	if( !p->sharable ){
sl@0	179	return SQLITE_OK;
sl@0	180	}
sl@0	181
sl@0	182	assert( SQLITE_OK==queryTableLock(p, iTable, eLock) );
sl@0	183
sl@0	184	/* If the read-uncommitted flag is set and a read-lock is requested,
sl@0	185	** return early without adding an entry to the BtShared.pLock list. See
sl@0	186	** comment in function queryTableLock() for more info on handling
sl@0	187	** the ReadUncommitted flag.
sl@0	188	*/
sl@0	189	if(
sl@0	190	(p->db->flags&SQLITE_ReadUncommitted) &&
sl@0	191	(eLock==READ_LOCK) &&
sl@0	192	iTable!=MASTER_ROOT
sl@0	193	){
sl@0	194	return SQLITE_OK;
sl@0	195	}
sl@0	196
sl@0	197	/* First search the list for an existing lock on this table. */
sl@0	198	for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
sl@0	199	if( pIter->iTable==iTable && pIter->pBtree==p ){
sl@0	200	pLock = pIter;
sl@0	201	break;
sl@0	202	}
sl@0	203	}
sl@0	204
sl@0	205	/* If the above search did not find a BtLock struct associating Btree p
sl@0	206	** with table iTable, allocate one and link it into the list.
sl@0	207	*/
sl@0	208	if( !pLock ){
sl@0	209	pLock = (BtLock *)sqlite3MallocZero(sizeof(BtLock));
sl@0	210	if( !pLock ){
sl@0	211	return SQLITE_NOMEM;
sl@0	212	}
sl@0	213	pLock->iTable = iTable;
sl@0	214	pLock->pBtree = p;
sl@0	215	pLock->pNext = pBt->pLock;
sl@0	216	pBt->pLock = pLock;
sl@0	217	}
sl@0	218
sl@0	219	/* Set the BtLock.eLock variable to the maximum of the current lock
sl@0	220	** and the requested lock. This means if a write-lock was already held
sl@0	221	** and a read-lock requested, we don't incorrectly downgrade the lock.
sl@0	222	*/
sl@0	223	assert( WRITE_LOCK>READ_LOCK );
sl@0	224	if( eLock>pLock->eLock ){
sl@0	225	pLock->eLock = eLock;
sl@0	226	}
sl@0	227
sl@0	228	return SQLITE_OK;
sl@0	229	}
sl@0	230	#endif /* !SQLITE_OMIT_SHARED_CACHE */
sl@0	231
sl@0	232	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	233	/*
sl@0	234	** Release all the table locks (locks obtained via calls to the lockTable()
sl@0	235	** procedure) held by Btree handle p.
sl@0	236	*/
sl@0	237	static void unlockAllTables(Btree *p){
sl@0	238	BtShared *pBt = p->pBt;
sl@0	239	BtLock **ppIter = &pBt->pLock;
sl@0	240
sl@0	241	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	242	assert( p->sharable \|\| 0==*ppIter );
sl@0	243
sl@0	244	while( *ppIter ){
sl@0	245	BtLock pLock = ppIter;
sl@0	246	assert( pBt->pExclusive==0 \|\| pBt->pExclusive==pLock->pBtree );
sl@0	247	if( pLock->pBtree==p ){
sl@0	248	*ppIter = pLock->pNext;
sl@0	249	sqlite3_free(pLock);
sl@0	250	}else{
sl@0	251	ppIter = &pLock->pNext;
sl@0	252	}
sl@0	253	}
sl@0	254
sl@0	255	if( pBt->pExclusive==p ){
sl@0	256	pBt->pExclusive = 0;
sl@0	257	}
sl@0	258	}
sl@0	259	#endif /* SQLITE_OMIT_SHARED_CACHE */
sl@0	260
sl@0	261	static void releasePage(MemPage pPage); / Forward reference */
sl@0	262
sl@0	263	/*
sl@0	264	** Verify that the cursor holds a mutex on the BtShared
sl@0	265	*/
sl@0	266	#ifndef NDEBUG
sl@0	267	static int cursorHoldsMutex(BtCursor *p){
sl@0	268	return sqlite3_mutex_held(p->pBt->mutex);
sl@0	269	}
sl@0	270	#endif
sl@0	271
sl@0	272
sl@0	273	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	274	/*
sl@0	275	** Invalidate the overflow page-list cache for cursor pCur, if any.
sl@0	276	*/
sl@0	277	static void invalidateOverflowCache(BtCursor *pCur){
sl@0	278	assert( cursorHoldsMutex(pCur) );
sl@0	279	sqlite3_free(pCur->aOverflow);
sl@0	280	pCur->aOverflow = 0;
sl@0	281	}
sl@0	282
sl@0	283	/*
sl@0	284	** Invalidate the overflow page-list cache for all cursors opened
sl@0	285	** on the shared btree structure pBt.
sl@0	286	*/
sl@0	287	static void invalidateAllOverflowCache(BtShared *pBt){
sl@0	288	BtCursor *p;
sl@0	289	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	290	for(p=pBt->pCursor; p; p=p->pNext){
sl@0	291	invalidateOverflowCache(p);
sl@0	292	}
sl@0	293	}
sl@0	294	#else
sl@0	295	#define invalidateOverflowCache(x)
sl@0	296	#define invalidateAllOverflowCache(x)
sl@0	297	#endif
sl@0	298
sl@0	299	/*
sl@0	300	** Save the current cursor position in the variables BtCursor.nKey
sl@0	301	** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
sl@0	302	*/
sl@0	303	static int saveCursorPosition(BtCursor *pCur){
sl@0	304	int rc;
sl@0	305
sl@0	306	assert( CURSOR_VALID==pCur->eState );
sl@0	307	assert( 0==pCur->pKey );
sl@0	308	assert( cursorHoldsMutex(pCur) );
sl@0	309
sl@0	310	rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
sl@0	311
sl@0	312	/* If this is an intKey table, then the above call to BtreeKeySize()
sl@0	313	** stores the integer key in pCur->nKey. In this case this value is
sl@0	314	** all that is required. Otherwise, if pCur is not open on an intKey
sl@0	315	** table, then malloc space for and store the pCur->nKey bytes of key
sl@0	316	** data.
sl@0	317	*/
sl@0	318	if( rc==SQLITE_OK && 0==pCur->apPage[0]->intKey){
sl@0	319	void *pKey = sqlite3Malloc(pCur->nKey);
sl@0	320	if( pKey ){
sl@0	321	rc = sqlite3BtreeKey(pCur, 0, pCur->nKey, pKey);
sl@0	322	if( rc==SQLITE_OK ){
sl@0	323	pCur->pKey = pKey;
sl@0	324	}else{
sl@0	325	sqlite3_free(pKey);
sl@0	326	}
sl@0	327	}else{
sl@0	328	rc = SQLITE_NOMEM;
sl@0	329	}
sl@0	330	}
sl@0	331	assert( !pCur->apPage[0]->intKey \|\| !pCur->pKey );
sl@0	332
sl@0	333	if( rc==SQLITE_OK ){
sl@0	334	int i;
sl@0	335	for(i=0; i<=pCur->iPage; i++){
sl@0	336	releasePage(pCur->apPage[i]);
sl@0	337	pCur->apPage[i] = 0;
sl@0	338	}
sl@0	339	pCur->iPage = -1;
sl@0	340	pCur->eState = CURSOR_REQUIRESEEK;
sl@0	341	}
sl@0	342
sl@0	343	invalidateOverflowCache(pCur);
sl@0	344	return rc;
sl@0	345	}
sl@0	346
sl@0	347	/*
sl@0	348	** Save the positions of all cursors except pExcept open on the table
sl@0	349	** with root-page iRoot. Usually, this is called just before cursor
sl@0	350	** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()).
sl@0	351	*/
sl@0	352	static int saveAllCursors(BtShared pBt, Pgno iRoot, BtCursor pExcept){
sl@0	353	BtCursor *p;
sl@0	354	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	355	assert( pExcept==0 \|\| pExcept->pBt==pBt );
sl@0	356	for(p=pBt->pCursor; p; p=p->pNext){
sl@0	357	if( p!=pExcept && (0==iRoot \|\| p->pgnoRoot==iRoot) &&
sl@0	358	p->eState==CURSOR_VALID ){
sl@0	359	int rc = saveCursorPosition(p);
sl@0	360	if( SQLITE_OK!=rc ){
sl@0	361	return rc;
sl@0	362	}
sl@0	363	}
sl@0	364	}
sl@0	365	return SQLITE_OK;
sl@0	366	}
sl@0	367
sl@0	368	/*
sl@0	369	** Clear the current cursor position.
sl@0	370	*/
sl@0	371	void sqlite3BtreeClearCursor(BtCursor *pCur){
sl@0	372	assert( cursorHoldsMutex(pCur) );
sl@0	373	sqlite3_free(pCur->pKey);
sl@0	374	pCur->pKey = 0;
sl@0	375	pCur->eState = CURSOR_INVALID;
sl@0	376	}
sl@0	377
sl@0	378	/*
sl@0	379	** Restore the cursor to the position it was in (or as close to as possible)
sl@0	380	** when saveCursorPosition() was called. Note that this call deletes the
sl@0	381	** saved position info stored by saveCursorPosition(), so there can be
sl@0	382	** at most one effective restoreCursorPosition() call after each
sl@0	383	** saveCursorPosition().
sl@0	384	*/
sl@0	385	int sqlite3BtreeRestoreCursorPosition(BtCursor *pCur){
sl@0	386	int rc;
sl@0	387	assert( cursorHoldsMutex(pCur) );
sl@0	388	assert( pCur->eState>=CURSOR_REQUIRESEEK );
sl@0	389	if( pCur->eState==CURSOR_FAULT ){
sl@0	390	return pCur->skip;
sl@0	391	}
sl@0	392	pCur->eState = CURSOR_INVALID;
sl@0	393	rc = sqlite3BtreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skip);
sl@0	394	if( rc==SQLITE_OK ){
sl@0	395	sqlite3_free(pCur->pKey);
sl@0	396	pCur->pKey = 0;
sl@0	397	assert( pCur->eState==CURSOR_VALID \|\| pCur->eState==CURSOR_INVALID );
sl@0	398	}
sl@0	399	return rc;
sl@0	400	}
sl@0	401
sl@0	402	#define restoreCursorPosition(p) \
sl@0	403	(p->eState>=CURSOR_REQUIRESEEK ? \
sl@0	404	sqlite3BtreeRestoreCursorPosition(p) : \
sl@0	405	SQLITE_OK)
sl@0	406
sl@0	407	/*
sl@0	408	** Determine whether or not a cursor has moved from the position it
sl@0	409	** was last placed at. Cursor can move when the row they are pointing
sl@0	410	** at is deleted out from under them.
sl@0	411	**
sl@0	412	** This routine returns an error code if something goes wrong. The
sl@0	413	** integer *pHasMoved is set to one if the cursor has moved and 0 if not.
sl@0	414	*/
sl@0	415	int sqlite3BtreeCursorHasMoved(BtCursor pCur, int pHasMoved){
sl@0	416	int rc;
sl@0	417
sl@0	418	rc = restoreCursorPosition(pCur);
sl@0	419	if( rc ){
sl@0	420	*pHasMoved = 1;
sl@0	421	return rc;
sl@0	422	}
sl@0	423	if( pCur->eState!=CURSOR_VALID \|\| pCur->skip!=0 ){
sl@0	424	*pHasMoved = 1;
sl@0	425	}else{
sl@0	426	*pHasMoved = 0;
sl@0	427	}
sl@0	428	return SQLITE_OK;
sl@0	429	}
sl@0	430
sl@0	431	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	432	/*
sl@0	433	** Given a page number of a regular database page, return the page
sl@0	434	** number for the pointer-map page that contains the entry for the
sl@0	435	** input page number.
sl@0	436	*/
sl@0	437	static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
sl@0	438	int nPagesPerMapPage, iPtrMap, ret;
sl@0	439	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	440	nPagesPerMapPage = (pBt->usableSize/5)+1;
sl@0	441	iPtrMap = (pgno-2)/nPagesPerMapPage;
sl@0	442	ret = (iPtrMap*nPagesPerMapPage) + 2;
sl@0	443	if( ret==PENDING_BYTE_PAGE(pBt) ){
sl@0	444	ret++;
sl@0	445	}
sl@0	446	return ret;
sl@0	447	}
sl@0	448
sl@0	449	/*
sl@0	450	** Write an entry into the pointer map.
sl@0	451	**
sl@0	452	** This routine updates the pointer map entry for page number 'key'
sl@0	453	** so that it maps to type 'eType' and parent page number 'pgno'.
sl@0	454	** An error code is returned if something goes wrong, otherwise SQLITE_OK.
sl@0	455	*/
sl@0	456	static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){
sl@0	457	DbPage pDbPage; / The pointer map page */
sl@0	458	u8 pPtrmap; / The pointer map data */
sl@0	459	Pgno iPtrmap; /* The pointer map page number */
sl@0	460	int offset; /* Offset in pointer map page */
sl@0	461	int rc;
sl@0	462
sl@0	463	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	464	/* The master-journal page number must never be used as a pointer map page */
sl@0	465	assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
sl@0	466
sl@0	467	assert( pBt->autoVacuum );
sl@0	468	if( key==0 ){
sl@0	469	return SQLITE_CORRUPT_BKPT;
sl@0	470	}
sl@0	471	iPtrmap = PTRMAP_PAGENO(pBt, key);
sl@0	472	rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
sl@0	473	if( rc!=SQLITE_OK ){
sl@0	474	return rc;
sl@0	475	}
sl@0	476	offset = PTRMAP_PTROFFSET(iPtrmap, key);
sl@0	477	pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
sl@0	478
sl@0	479	if( eType!=pPtrmap[offset] \|\| get4byte(&pPtrmap[offset+1])!=parent ){
sl@0	480	TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
sl@0	481	rc = sqlite3PagerWrite(pDbPage);
sl@0	482	if( rc==SQLITE_OK ){
sl@0	483	pPtrmap[offset] = eType;
sl@0	484	put4byte(&pPtrmap[offset+1], parent);
sl@0	485	}
sl@0	486	}
sl@0	487
sl@0	488	sqlite3PagerUnref(pDbPage);
sl@0	489	return rc;
sl@0	490	}
sl@0	491
sl@0	492	/*
sl@0	493	** Read an entry from the pointer map.
sl@0	494	**
sl@0	495	** This routine retrieves the pointer map entry for page 'key', writing
sl@0	496	** the type and parent page number to pEType and pPgno respectively.
sl@0	497	** An error code is returned if something goes wrong, otherwise SQLITE_OK.
sl@0	498	*/
sl@0	499	static int ptrmapGet(BtShared pBt, Pgno key, u8 pEType, Pgno *pPgno){
sl@0	500	DbPage pDbPage; / The pointer map page */
sl@0	501	int iPtrmap; /* Pointer map page index */
sl@0	502	u8 pPtrmap; / Pointer map page data */
sl@0	503	int offset; /* Offset of entry in pointer map */
sl@0	504	int rc;
sl@0	505
sl@0	506	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	507
sl@0	508	iPtrmap = PTRMAP_PAGENO(pBt, key);
sl@0	509	rc = sqlite3PagerGet(pBt->pPager, iPtrmap, &pDbPage);
sl@0	510	if( rc!=0 ){
sl@0	511	return rc;
sl@0	512	}
sl@0	513	pPtrmap = (u8 *)sqlite3PagerGetData(pDbPage);
sl@0	514
sl@0	515	offset = PTRMAP_PTROFFSET(iPtrmap, key);
sl@0	516	assert( pEType!=0 );
sl@0	517	*pEType = pPtrmap[offset];
sl@0	518	if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
sl@0	519
sl@0	520	sqlite3PagerUnref(pDbPage);
sl@0	521	if( pEType<1 \|\| pEType>5 ) return SQLITE_CORRUPT_BKPT;
sl@0	522	return SQLITE_OK;
sl@0	523	}
sl@0	524
sl@0	525	#else /* if defined SQLITE_OMIT_AUTOVACUUM */
sl@0	526	#define ptrmapPut(w,x,y,z) SQLITE_OK
sl@0	527	#define ptrmapGet(w,x,y,z) SQLITE_OK
sl@0	528	#define ptrmapPutOvfl(y,z) SQLITE_OK
sl@0	529	#endif
sl@0	530
sl@0	531	/*
sl@0	532	** Given a btree page and a cell index (0 means the first cell on
sl@0	533	** the page, 1 means the second cell, and so forth) return a pointer
sl@0	534	** to the cell content.
sl@0	535	**
sl@0	536	** This routine works only for pages that do not contain overflow cells.
sl@0	537	*/
sl@0	538	#define findCell(P,I) \
sl@0	539	((P)->aData + ((P)->maskPage & get2byte(&(P)->aData[(P)->cellOffset+2*(I)])))
sl@0	540
sl@0	541	/*
sl@0	542	** This a more complex version of findCell() that works for
sl@0	543	** pages that do contain overflow cells. See insert
sl@0	544	*/
sl@0	545	static u8 findOverflowCell(MemPage pPage, int iCell){
sl@0	546	int i;
sl@0	547	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	548	for(i=pPage->nOverflow-1; i>=0; i--){
sl@0	549	int k;
sl@0	550	struct _OvflCell *pOvfl;
sl@0	551	pOvfl = &pPage->aOvfl[i];
sl@0	552	k = pOvfl->idx;
sl@0	553	if( k<=iCell ){
sl@0	554	if( k==iCell ){
sl@0	555	return pOvfl->pCell;
sl@0	556	}
sl@0	557	iCell--;
sl@0	558	}
sl@0	559	}
sl@0	560	return findCell(pPage, iCell);
sl@0	561	}
sl@0	562
sl@0	563	/*
sl@0	564	** Parse a cell content block and fill in the CellInfo structure. There
sl@0	565	** are two versions of this function. sqlite3BtreeParseCell() takes a
sl@0	566	** cell index as the second argument and sqlite3BtreeParseCellPtr()
sl@0	567	** takes a pointer to the body of the cell as its second argument.
sl@0	568	**
sl@0	569	** Within this file, the parseCell() macro can be called instead of
sl@0	570	** sqlite3BtreeParseCellPtr(). Using some compilers, this will be faster.
sl@0	571	*/
sl@0	572	void sqlite3BtreeParseCellPtr(
sl@0	573	MemPage pPage, / Page containing the cell */
sl@0	574	u8 pCell, / Pointer to the cell text. */
sl@0	575	CellInfo pInfo / Fill in this structure */
sl@0	576	){
sl@0	577	int n; /* Number bytes in cell content header */
sl@0	578	u32 nPayload; /* Number of bytes of cell payload */
sl@0	579
sl@0	580	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	581
sl@0	582	pInfo->pCell = pCell;
sl@0	583	assert( pPage->leaf==0 \|\| pPage->leaf==1 );
sl@0	584	n = pPage->childPtrSize;
sl@0	585	assert( n==4-4*pPage->leaf );
sl@0	586	if( pPage->intKey ){
sl@0	587	if( pPage->hasData ){
sl@0	588	n += getVarint32(&pCell[n], nPayload);
sl@0	589	}else{
sl@0	590	nPayload = 0;
sl@0	591	}
sl@0	592	n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
sl@0	593	pInfo->nData = nPayload;
sl@0	594	}else{
sl@0	595	pInfo->nData = 0;
sl@0	596	n += getVarint32(&pCell[n], nPayload);
sl@0	597	pInfo->nKey = nPayload;
sl@0	598	}
sl@0	599	pInfo->nPayload = nPayload;
sl@0	600	pInfo->nHeader = n;
sl@0	601	if( likely(nPayload<=pPage->maxLocal) ){
sl@0	602	/* This is the (easy) common case where the entire payload fits
sl@0	603	** on the local page. No overflow is required.
sl@0	604	*/
sl@0	605	int nSize; /* Total size of cell content in bytes */
sl@0	606	nSize = nPayload + n;
sl@0	607	pInfo->nLocal = nPayload;
sl@0	608	pInfo->iOverflow = 0;
sl@0	609	if( (nSize & ~3)==0 ){
sl@0	610	nSize = 4; /* Minimum cell size is 4 */
sl@0	611	}
sl@0	612	pInfo->nSize = nSize;
sl@0	613	}else{
sl@0	614	/* If the payload will not fit completely on the local page, we have
sl@0	615	** to decide how much to store locally and how much to spill onto
sl@0	616	** overflow pages. The strategy is to minimize the amount of unused
sl@0	617	** space on overflow pages while keeping the amount of local storage
sl@0	618	** in between minLocal and maxLocal.
sl@0	619	**
sl@0	620	** Warning: changing the way overflow payload is distributed in any
sl@0	621	** way will result in an incompatible file format.
sl@0	622	*/
sl@0	623	int minLocal; /* Minimum amount of payload held locally */
sl@0	624	int maxLocal; /* Maximum amount of payload held locally */
sl@0	625	int surplus; /* Overflow payload available for local storage */
sl@0	626
sl@0	627	minLocal = pPage->minLocal;
sl@0	628	maxLocal = pPage->maxLocal;
sl@0	629	surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
sl@0	630	if( surplus <= maxLocal ){
sl@0	631	pInfo->nLocal = surplus;
sl@0	632	}else{
sl@0	633	pInfo->nLocal = minLocal;
sl@0	634	}
sl@0	635	pInfo->iOverflow = pInfo->nLocal + n;
sl@0	636	pInfo->nSize = pInfo->iOverflow + 4;
sl@0	637	}
sl@0	638	}
sl@0	639	#define parseCell(pPage, iCell, pInfo) \
sl@0	640	sqlite3BtreeParseCellPtr((pPage), findCell((pPage), (iCell)), (pInfo))
sl@0	641	void sqlite3BtreeParseCell(
sl@0	642	MemPage pPage, / Page containing the cell */
sl@0	643	int iCell, /* The cell index. First cell is 0 */
sl@0	644	CellInfo pInfo / Fill in this structure */
sl@0	645	){
sl@0	646	parseCell(pPage, iCell, pInfo);
sl@0	647	}
sl@0	648
sl@0	649	/*
sl@0	650	** Compute the total number of bytes that a Cell needs in the cell
sl@0	651	** data area of the btree-page. The return number includes the cell
sl@0	652	** data header and the local payload, but not any overflow page or
sl@0	653	** the space used by the cell pointer.
sl@0	654	*/
sl@0	655	#ifndef NDEBUG
sl@0	656	static u16 cellSize(MemPage *pPage, int iCell){
sl@0	657	CellInfo info;
sl@0	658	sqlite3BtreeParseCell(pPage, iCell, &info);
sl@0	659	return info.nSize;
sl@0	660	}
sl@0	661	#endif
sl@0	662	static u16 cellSizePtr(MemPage pPage, u8 pCell){
sl@0	663	CellInfo info;
sl@0	664	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	665	return info.nSize;
sl@0	666	}
sl@0	667
sl@0	668	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	669	/*
sl@0	670	** If the cell pCell, part of page pPage contains a pointer
sl@0	671	** to an overflow page, insert an entry into the pointer-map
sl@0	672	** for the overflow page.
sl@0	673	*/
sl@0	674	static int ptrmapPutOvflPtr(MemPage pPage, u8 pCell){
sl@0	675	CellInfo info;
sl@0	676	assert( pCell!=0 );
sl@0	677	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	678	assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
sl@0	679	if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){
sl@0	680	Pgno ovfl = get4byte(&pCell[info.iOverflow]);
sl@0	681	return ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno);
sl@0	682	}
sl@0	683	return SQLITE_OK;
sl@0	684	}
sl@0	685	/*
sl@0	686	** If the cell with index iCell on page pPage contains a pointer
sl@0	687	** to an overflow page, insert an entry into the pointer-map
sl@0	688	** for the overflow page.
sl@0	689	*/
sl@0	690	static int ptrmapPutOvfl(MemPage *pPage, int iCell){
sl@0	691	u8 *pCell;
sl@0	692	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	693	pCell = findOverflowCell(pPage, iCell);
sl@0	694	return ptrmapPutOvflPtr(pPage, pCell);
sl@0	695	}
sl@0	696	#endif
sl@0	697
sl@0	698
sl@0	699	/*
sl@0	700	** Defragment the page given. All Cells are moved to the
sl@0	701	** end of the page and all free space is collected into one
sl@0	702	** big FreeBlk that occurs in between the header and cell
sl@0	703	** pointer array and the cell content area.
sl@0	704	*/
sl@0	705	static int defragmentPage(MemPage *pPage){
sl@0	706	int i; /* Loop counter */
sl@0	707	int pc; /* Address of a i-th cell */
sl@0	708	int addr; /* Offset of first byte after cell pointer array */
sl@0	709	int hdr; /* Offset to the page header */
sl@0	710	int size; /* Size of a cell */
sl@0	711	int usableSize; /* Number of usable bytes on a page */
sl@0	712	int cellOffset; /* Offset to the cell pointer array */
sl@0	713	int cbrk; /* Offset to the cell content area */
sl@0	714	int nCell; /* Number of cells on the page */
sl@0	715	unsigned char data; / The page data */
sl@0	716	unsigned char temp; / Temp area for cell content */
sl@0	717
sl@0	718	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
sl@0	719	assert( pPage->pBt!=0 );
sl@0	720	assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
sl@0	721	assert( pPage->nOverflow==0 );
sl@0	722	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	723	temp = sqlite3PagerTempSpace(pPage->pBt->pPager);
sl@0	724	data = pPage->aData;
sl@0	725	hdr = pPage->hdrOffset;
sl@0	726	cellOffset = pPage->cellOffset;
sl@0	727	nCell = pPage->nCell;
sl@0	728	assert( nCell==get2byte(&data[hdr+3]) );
sl@0	729	usableSize = pPage->pBt->usableSize;
sl@0	730	cbrk = get2byte(&data[hdr+5]);
sl@0	731	memcpy(&temp[cbrk], &data[cbrk], usableSize - cbrk);
sl@0	732	cbrk = usableSize;
sl@0	733	for(i=0; i<nCell; i++){
sl@0	734	u8 pAddr; / The i-th cell pointer */
sl@0	735	pAddr = &data[cellOffset + i*2];
sl@0	736	pc = get2byte(pAddr);
sl@0	737	if( pc>=usableSize ){
sl@0	738	return SQLITE_CORRUPT_BKPT;
sl@0	739	}
sl@0	740	size = cellSizePtr(pPage, &temp[pc]);
sl@0	741	cbrk -= size;
sl@0	742	if( cbrk<cellOffset+2*nCell \|\| pc+size>usableSize ){
sl@0	743	return SQLITE_CORRUPT_BKPT;
sl@0	744	}
sl@0	745	assert( cbrk+size<=usableSize && cbrk>=0 );
sl@0	746	memcpy(&data[cbrk], &temp[pc], size);
sl@0	747	put2byte(pAddr, cbrk);
sl@0	748	}
sl@0	749	assert( cbrk>=cellOffset+2*nCell );
sl@0	750	put2byte(&data[hdr+5], cbrk);
sl@0	751	data[hdr+1] = 0;
sl@0	752	data[hdr+2] = 0;
sl@0	753	data[hdr+7] = 0;
sl@0	754	addr = cellOffset+2*nCell;
sl@0	755	memset(&data[addr], 0, cbrk-addr);
sl@0	756	if( cbrk-addr!=pPage->nFree ){
sl@0	757	return SQLITE_CORRUPT_BKPT;
sl@0	758	}
sl@0	759	return SQLITE_OK;
sl@0	760	}
sl@0	761
sl@0	762	/*
sl@0	763	** Allocate nByte bytes of space on a page.
sl@0	764	**
sl@0	765	** Return the index into pPage->aData[] of the first byte of
sl@0	766	** the new allocation. The caller guarantees that there is enough
sl@0	767	** space. This routine will never fail.
sl@0	768	**
sl@0	769	** If the page contains nBytes of free space but does not contain
sl@0	770	** nBytes of contiguous free space, then this routine automatically
sl@0	771	** calls defragementPage() to consolidate all free space before
sl@0	772	** allocating the new chunk.
sl@0	773	*/
sl@0	774	static int allocateSpace(MemPage *pPage, int nByte){
sl@0	775	int addr, pc, hdr;
sl@0	776	int size;
sl@0	777	int nFrag;
sl@0	778	int top;
sl@0	779	int nCell;
sl@0	780	int cellOffset;
sl@0	781	unsigned char *data;
sl@0	782
sl@0	783	data = pPage->aData;
sl@0	784	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
sl@0	785	assert( pPage->pBt );
sl@0	786	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	787	assert( nByte>=0 ); /* Minimum cell size is 4 */
sl@0	788	assert( pPage->nFree>=nByte );
sl@0	789	assert( pPage->nOverflow==0 );
sl@0	790	pPage->nFree -= nByte;
sl@0	791	hdr = pPage->hdrOffset;
sl@0	792
sl@0	793	nFrag = data[hdr+7];
sl@0	794	if( nFrag<60 ){
sl@0	795	/* Search the freelist looking for a slot big enough to satisfy the
sl@0	796	** space request. */
sl@0	797	addr = hdr+1;
sl@0	798	while( (pc = get2byte(&data[addr]))>0 ){
sl@0	799	size = get2byte(&data[pc+2]);
sl@0	800	if( size>=nByte ){
sl@0	801	if( size<nByte+4 ){
sl@0	802	memcpy(&data[addr], &data[pc], 2);
sl@0	803	data[hdr+7] = nFrag + size - nByte;
sl@0	804	return pc;
sl@0	805	}else{
sl@0	806	put2byte(&data[pc+2], size-nByte);
sl@0	807	return pc + size - nByte;
sl@0	808	}
sl@0	809	}
sl@0	810	addr = pc;
sl@0	811	}
sl@0	812	}
sl@0	813
sl@0	814	/* Allocate memory from the gap in between the cell pointer array
sl@0	815	** and the cell content area.
sl@0	816	*/
sl@0	817	top = get2byte(&data[hdr+5]);
sl@0	818	nCell = get2byte(&data[hdr+3]);
sl@0	819	cellOffset = pPage->cellOffset;
sl@0	820	if( nFrag>=60 \|\| cellOffset + 2*nCell > top - nByte ){
sl@0	821	defragmentPage(pPage);
sl@0	822	top = get2byte(&data[hdr+5]);
sl@0	823	}
sl@0	824	top -= nByte;
sl@0	825	assert( cellOffset + 2*nCell <= top );
sl@0	826	put2byte(&data[hdr+5], top);
sl@0	827	return top;
sl@0	828	}
sl@0	829
sl@0	830	/*
sl@0	831	** Return a section of the pPage->aData to the freelist.
sl@0	832	** The first byte of the new free block is pPage->aDisk[start]
sl@0	833	** and the size of the block is "size" bytes.
sl@0	834	**
sl@0	835	** Most of the effort here is involved in coalesing adjacent
sl@0	836	** free blocks into a single big free block.
sl@0	837	*/
sl@0	838	static int freeSpace(MemPage *pPage, int start, int size){
sl@0	839	int addr, pbegin, hdr;
sl@0	840	unsigned char *data = pPage->aData;
sl@0	841
sl@0	842	assert( pPage->pBt!=0 );
sl@0	843	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
sl@0	844	assert( start>=pPage->hdrOffset+6+(pPage->leaf?0:4) );
sl@0	845	assert( (start + size)<=pPage->pBt->usableSize );
sl@0	846	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	847	assert( size>=0 ); /* Minimum cell size is 4 */
sl@0	848
sl@0	849	#ifdef SQLITE_SECURE_DELETE
sl@0	850	/* Overwrite deleted information with zeros when the SECURE_DELETE
sl@0	851	** option is enabled at compile-time */
sl@0	852	memset(&data[start], 0, size);
sl@0	853	#endif
sl@0	854
sl@0	855	/* Add the space back into the linked list of freeblocks */
sl@0	856	hdr = pPage->hdrOffset;
sl@0	857	addr = hdr + 1;
sl@0	858	while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){
sl@0	859	assert( pbegin<=pPage->pBt->usableSize-4 );
sl@0	860	if( pbegin<=addr ) return SQLITE_CORRUPT_BKPT;
sl@0	861	addr = pbegin;
sl@0	862	}
sl@0	863	if( pbegin>pPage->pBt->usableSize-4 ) return SQLITE_CORRUPT_BKPT;
sl@0	864	assert( pbegin>addr \|\| pbegin==0 );
sl@0	865	put2byte(&data[addr], start);
sl@0	866	put2byte(&data[start], pbegin);
sl@0	867	put2byte(&data[start+2], size);
sl@0	868	pPage->nFree += size;
sl@0	869
sl@0	870	/* Coalesce adjacent free blocks */
sl@0	871	addr = pPage->hdrOffset + 1;
sl@0	872	while( (pbegin = get2byte(&data[addr]))>0 ){
sl@0	873	int pnext, psize;
sl@0	874	assert( pbegin>addr );
sl@0	875	assert( pbegin<=pPage->pBt->usableSize-4 );
sl@0	876	pnext = get2byte(&data[pbegin]);
sl@0	877	psize = get2byte(&data[pbegin+2]);
sl@0	878	if( pbegin + psize + 3 >= pnext && pnext>0 ){
sl@0	879	int frag = pnext - (pbegin+psize);
sl@0	880	if( frag<0 \|\| frag>data[pPage->hdrOffset+7] ) return SQLITE_CORRUPT_BKPT;
sl@0	881	data[pPage->hdrOffset+7] -= frag;
sl@0	882	put2byte(&data[pbegin], get2byte(&data[pnext]));
sl@0	883	put2byte(&data[pbegin+2], pnext+get2byte(&data[pnext+2])-pbegin);
sl@0	884	}else{
sl@0	885	addr = pbegin;
sl@0	886	}
sl@0	887	}
sl@0	888
sl@0	889	/* If the cell content area begins with a freeblock, remove it. */
sl@0	890	if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
sl@0	891	int top;
sl@0	892	pbegin = get2byte(&data[hdr+1]);
sl@0	893	memcpy(&data[hdr+1], &data[pbegin], 2);
sl@0	894	top = get2byte(&data[hdr+5]);
sl@0	895	put2byte(&data[hdr+5], top + get2byte(&data[pbegin+2]));
sl@0	896	}
sl@0	897	return SQLITE_OK;
sl@0	898	}
sl@0	899
sl@0	900	/*
sl@0	901	** Decode the flags byte (the first byte of the header) for a page
sl@0	902	** and initialize fields of the MemPage structure accordingly.
sl@0	903	**
sl@0	904	** Only the following combinations are supported. Anything different
sl@0	905	** indicates a corrupt database files:
sl@0	906	**
sl@0	907	** PTF_ZERODATA
sl@0	908	** PTF_ZERODATA \| PTF_LEAF
sl@0	909	** PTF_LEAFDATA \| PTF_INTKEY
sl@0	910	** PTF_LEAFDATA \| PTF_INTKEY \| PTF_LEAF
sl@0	911	*/
sl@0	912	static int decodeFlags(MemPage *pPage, int flagByte){
sl@0	913	BtShared pBt; / A copy of pPage->pBt */
sl@0	914
sl@0	915	assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
sl@0	916	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	917	pPage->leaf = flagByte>>3; assert( PTF_LEAF == 1<<3 );
sl@0	918	flagByte &= ~PTF_LEAF;
sl@0	919	pPage->childPtrSize = 4-4*pPage->leaf;
sl@0	920	pBt = pPage->pBt;
sl@0	921	if( flagByte==(PTF_LEAFDATA \| PTF_INTKEY) ){
sl@0	922	pPage->intKey = 1;
sl@0	923	pPage->hasData = pPage->leaf;
sl@0	924	pPage->maxLocal = pBt->maxLeaf;
sl@0	925	pPage->minLocal = pBt->minLeaf;
sl@0	926	}else if( flagByte==PTF_ZERODATA ){
sl@0	927	pPage->intKey = 0;
sl@0	928	pPage->hasData = 0;
sl@0	929	pPage->maxLocal = pBt->maxLocal;
sl@0	930	pPage->minLocal = pBt->minLocal;
sl@0	931	}else{
sl@0	932	return SQLITE_CORRUPT_BKPT;
sl@0	933	}
sl@0	934	return SQLITE_OK;
sl@0	935	}
sl@0	936
sl@0	937	/*
sl@0	938	** Initialize the auxiliary information for a disk block.
sl@0	939	**
sl@0	940	** Return SQLITE_OK on success. If we see that the page does
sl@0	941	** not contain a well-formed database page, then return
sl@0	942	** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
sl@0	943	** guarantee that the page is well-formed. It only shows that
sl@0	944	** we failed to detect any corruption.
sl@0	945	*/
sl@0	946	int sqlite3BtreeInitPage(MemPage *pPage){
sl@0	947
sl@0	948	assert( pPage->pBt!=0 );
sl@0	949	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	950	assert( pPage->pgno==sqlite3PagerPagenumber(pPage->pDbPage) );
sl@0	951	assert( pPage == sqlite3PagerGetExtra(pPage->pDbPage) );
sl@0	952	assert( pPage->aData == sqlite3PagerGetData(pPage->pDbPage) );
sl@0	953
sl@0	954	if( !pPage->isInit ){
sl@0	955	int pc; /* Address of a freeblock within pPage->aData[] */
sl@0	956	int hdr; /* Offset to beginning of page header */
sl@0	957	u8 data; / Equal to pPage->aData */
sl@0	958	BtShared pBt; / The main btree structure */
sl@0	959	int usableSize; /* Amount of usable space on each page */
sl@0	960	int cellOffset; /* Offset from start of page to first cell pointer */
sl@0	961	int nFree; /* Number of unused bytes on the page */
sl@0	962	int top; /* First byte of the cell content area */
sl@0	963
sl@0	964	pBt = pPage->pBt;
sl@0	965
sl@0	966	hdr = pPage->hdrOffset;
sl@0	967	data = pPage->aData;
sl@0	968	if( decodeFlags(pPage, data[hdr]) ) return SQLITE_CORRUPT_BKPT;
sl@0	969	assert( pBt->pageSize>=512 && pBt->pageSize<=32768 );
sl@0	970	pPage->maskPage = pBt->pageSize - 1;
sl@0	971	pPage->nOverflow = 0;
sl@0	972	usableSize = pBt->usableSize;
sl@0	973	pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
sl@0	974	top = get2byte(&data[hdr+5]);
sl@0	975	pPage->nCell = get2byte(&data[hdr+3]);
sl@0	976	if( pPage->nCell>MX_CELL(pBt) ){
sl@0	977	/* To many cells for a single page. The page must be corrupt */
sl@0	978	return SQLITE_CORRUPT_BKPT;
sl@0	979	}
sl@0	980
sl@0	981	/* Compute the total free space on the page */
sl@0	982	pc = get2byte(&data[hdr+1]);
sl@0	983	nFree = data[hdr+7] + top - (cellOffset + 2*pPage->nCell);
sl@0	984	while( pc>0 ){
sl@0	985	int next, size;
sl@0	986	if( pc>usableSize-4 ){
sl@0	987	/* Free block is off the page */
sl@0	988	return SQLITE_CORRUPT_BKPT;
sl@0	989	}
sl@0	990	next = get2byte(&data[pc]);
sl@0	991	size = get2byte(&data[pc+2]);
sl@0	992	if( next>0 && next<=pc+size+3 ){
sl@0	993	/* Free blocks must be in accending order */
sl@0	994	return SQLITE_CORRUPT_BKPT;
sl@0	995	}
sl@0	996	nFree += size;
sl@0	997	pc = next;
sl@0	998	}
sl@0	999	pPage->nFree = nFree;
sl@0	1000	if( nFree>=usableSize ){
sl@0	1001	/* Free space cannot exceed total page size */
sl@0	1002	return SQLITE_CORRUPT_BKPT;
sl@0	1003	}
sl@0	1004
sl@0	1005	#if 0
sl@0	1006	/* Check that all the offsets in the cell offset array are within range.
sl@0	1007	**
sl@0	1008	** Omitting this consistency check and using the pPage->maskPage mask
sl@0	1009	** to prevent overrunning the page buffer in findCell() results in a
sl@0	1010	** 2.5% performance gain.
sl@0	1011	*/
sl@0	1012	{
sl@0	1013	u8 pOff; / Iterator used to check all cell offsets are in range */
sl@0	1014	u8 pEnd; / Pointer to end of cell offset array */
sl@0	1015	u8 mask; /* Mask of bits that must be zero in MSB of cell offsets */
sl@0	1016	mask = ~(((u8)(pBt->pageSize>>8))-1);
sl@0	1017	pEnd = &data[cellOffset + pPage->nCell*2];
sl@0	1018	for(pOff=&data[cellOffset]; pOff!=pEnd && !((*pOff)&mask); pOff+=2);
sl@0	1019	if( pOff!=pEnd ){
sl@0	1020	return SQLITE_CORRUPT_BKPT;
sl@0	1021	}
sl@0	1022	}
sl@0	1023	#endif
sl@0	1024
sl@0	1025	pPage->isInit = 1;
sl@0	1026	}
sl@0	1027	return SQLITE_OK;
sl@0	1028	}
sl@0	1029
sl@0	1030	/*
sl@0	1031	** Set up a raw page so that it looks like a database page holding
sl@0	1032	** no entries.
sl@0	1033	*/
sl@0	1034	static void zeroPage(MemPage *pPage, int flags){
sl@0	1035	unsigned char *data = pPage->aData;
sl@0	1036	BtShared *pBt = pPage->pBt;
sl@0	1037	int hdr = pPage->hdrOffset;
sl@0	1038	int first;
sl@0	1039
sl@0	1040	assert( sqlite3PagerPagenumber(pPage->pDbPage)==pPage->pgno );
sl@0	1041	assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
sl@0	1042	assert( sqlite3PagerGetData(pPage->pDbPage) == data );
sl@0	1043	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
sl@0	1044	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	1045	/memset(&data[hdr], 0, pBt->usableSize - hdr);/
sl@0	1046	data[hdr] = flags;
sl@0	1047	first = hdr + 8 + 4*((flags&PTF_LEAF)==0);
sl@0	1048	memset(&data[hdr+1], 0, 4);
sl@0	1049	data[hdr+7] = 0;
sl@0	1050	put2byte(&data[hdr+5], pBt->usableSize);
sl@0	1051	pPage->nFree = pBt->usableSize - first;
sl@0	1052	decodeFlags(pPage, flags);
sl@0	1053	pPage->hdrOffset = hdr;
sl@0	1054	pPage->cellOffset = first;
sl@0	1055	pPage->nOverflow = 0;
sl@0	1056	assert( pBt->pageSize>=512 && pBt->pageSize<=32768 );
sl@0	1057	pPage->maskPage = pBt->pageSize - 1;
sl@0	1058	pPage->nCell = 0;
sl@0	1059	pPage->isInit = 1;
sl@0	1060	}
sl@0	1061
sl@0	1062
sl@0	1063	/*
sl@0	1064	** Convert a DbPage obtained from the pager into a MemPage used by
sl@0	1065	** the btree layer.
sl@0	1066	*/
sl@0	1067	static MemPage btreePageFromDbPage(DbPage pDbPage, Pgno pgno, BtShared *pBt){
sl@0	1068	MemPage pPage = (MemPage)sqlite3PagerGetExtra(pDbPage);
sl@0	1069	pPage->aData = sqlite3PagerGetData(pDbPage);
sl@0	1070	pPage->pDbPage = pDbPage;
sl@0	1071	pPage->pBt = pBt;
sl@0	1072	pPage->pgno = pgno;
sl@0	1073	pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
sl@0	1074	return pPage;
sl@0	1075	}
sl@0	1076
sl@0	1077	/*
sl@0	1078	** Get a page from the pager. Initialize the MemPage.pBt and
sl@0	1079	** MemPage.aData elements if needed.
sl@0	1080	**
sl@0	1081	** If the noContent flag is set, it means that we do not care about
sl@0	1082	** the content of the page at this time. So do not go to the disk
sl@0	1083	** to fetch the content. Just fill in the content with zeros for now.
sl@0	1084	** If in the future we call sqlite3PagerWrite() on this page, that
sl@0	1085	** means we have started to be concerned about content and the disk
sl@0	1086	** read should occur at that point.
sl@0	1087	*/
sl@0	1088	int sqlite3BtreeGetPage(
sl@0	1089	BtShared pBt, / The btree */
sl@0	1090	Pgno pgno, /* Number of the page to fetch */
sl@0	1091	MemPage *ppPage, / Return the page in this parameter */
sl@0	1092	int noContent /* Do not load page content if true */
sl@0	1093	){
sl@0	1094	int rc;
sl@0	1095	DbPage *pDbPage;
sl@0	1096
sl@0	1097	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	1098	rc = sqlite3PagerAcquire(pBt->pPager, pgno, (DbPage**)&pDbPage, noContent);
sl@0	1099	if( rc ) return rc;
sl@0	1100	*ppPage = btreePageFromDbPage(pDbPage, pgno, pBt);
sl@0	1101	return SQLITE_OK;
sl@0	1102	}
sl@0	1103
sl@0	1104	/*
sl@0	1105	** Return the size of the database file in pages. Or return -1 if
sl@0	1106	** there is any kind of error.
sl@0	1107	*/
sl@0	1108	static int pagerPagecount(Pager *pPager){
sl@0	1109	int rc;
sl@0	1110	int nPage;
sl@0	1111	rc = sqlite3PagerPagecount(pPager, &nPage);
sl@0	1112	return (rc==SQLITE_OK?nPage:-1);
sl@0	1113	}
sl@0	1114
sl@0	1115	/*
sl@0	1116	** Get a page from the pager and initialize it. This routine
sl@0	1117	** is just a convenience wrapper around separate calls to
sl@0	1118	** sqlite3BtreeGetPage() and sqlite3BtreeInitPage().
sl@0	1119	*/
sl@0	1120	static int getAndInitPage(
sl@0	1121	BtShared pBt, / The database file */
sl@0	1122	Pgno pgno, /* Number of the page to get */
sl@0	1123	MemPage *ppPage / Write the page pointer here */
sl@0	1124	){
sl@0	1125	int rc;
sl@0	1126	DbPage *pDbPage;
sl@0	1127	MemPage *pPage;
sl@0	1128
sl@0	1129	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	1130	if( pgno==0 ){
sl@0	1131	return SQLITE_CORRUPT_BKPT;
sl@0	1132	}
sl@0	1133
sl@0	1134	/* It is often the case that the page we want is already in cache.
sl@0	1135	** If so, get it directly. This saves us from having to call
sl@0	1136	** pagerPagecount() to make sure pgno is within limits, which results
sl@0	1137	** in a measureable performance improvements.
sl@0	1138	*/
sl@0	1139	pDbPage = sqlite3PagerLookup(pBt->pPager, pgno);
sl@0	1140	if( pDbPage ){
sl@0	1141	/* Page is already in cache */
sl@0	1142	*ppPage = pPage = btreePageFromDbPage(pDbPage, pgno, pBt);
sl@0	1143	rc = SQLITE_OK;
sl@0	1144	}else{
sl@0	1145	/* Page not in cache. Acquire it. */
sl@0	1146	if( pgno>pagerPagecount(pBt->pPager) ){
sl@0	1147	return SQLITE_CORRUPT_BKPT;
sl@0	1148	}
sl@0	1149	rc = sqlite3BtreeGetPage(pBt, pgno, ppPage, 0);
sl@0	1150	if( rc ) return rc;
sl@0	1151	pPage = *ppPage;
sl@0	1152	}
sl@0	1153	if( !pPage->isInit ){
sl@0	1154	rc = sqlite3BtreeInitPage(pPage);
sl@0	1155	}
sl@0	1156	if( rc!=SQLITE_OK ){
sl@0	1157	releasePage(pPage);
sl@0	1158	*ppPage = 0;
sl@0	1159	}
sl@0	1160	return rc;
sl@0	1161	}
sl@0	1162
sl@0	1163	/*
sl@0	1164	** Release a MemPage. This should be called once for each prior
sl@0	1165	** call to sqlite3BtreeGetPage.
sl@0	1166	*/
sl@0	1167	static void releasePage(MemPage *pPage){
sl@0	1168	if( pPage ){
sl@0	1169	assert( pPage->aData );
sl@0	1170	assert( pPage->pBt );
sl@0	1171	assert( sqlite3PagerGetExtra(pPage->pDbPage) == (void*)pPage );
sl@0	1172	assert( sqlite3PagerGetData(pPage->pDbPage)==pPage->aData );
sl@0	1173	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	1174	sqlite3PagerUnref(pPage->pDbPage);
sl@0	1175	}
sl@0	1176	}
sl@0	1177
sl@0	1178	/*
sl@0	1179	** During a rollback, when the pager reloads information into the cache
sl@0	1180	** so that the cache is restored to its original state at the start of
sl@0	1181	** the transaction, for each page restored this routine is called.
sl@0	1182	**
sl@0	1183	** This routine needs to reset the extra data section at the end of the
sl@0	1184	** page to agree with the restored data.
sl@0	1185	*/
sl@0	1186	static void pageReinit(DbPage *pData){
sl@0	1187	MemPage *pPage;
sl@0	1188	pPage = (MemPage *)sqlite3PagerGetExtra(pData);
sl@0	1189	if( pPage->isInit ){
sl@0	1190	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	1191	pPage->isInit = 0;
sl@0	1192	if( sqlite3PagerPageRefcount(pData)>0 ){
sl@0	1193	sqlite3BtreeInitPage(pPage);
sl@0	1194	}
sl@0	1195	}
sl@0	1196	}
sl@0	1197
sl@0	1198	/*
sl@0	1199	** Invoke the busy handler for a btree.
sl@0	1200	*/
sl@0	1201	static int sqlite3BtreeInvokeBusyHandler(void *pArg, int n){
sl@0	1202	BtShared pBt = (BtShared)pArg;
sl@0	1203	assert( pBt->db );
sl@0	1204	assert( sqlite3_mutex_held(pBt->db->mutex) );
sl@0	1205	return sqlite3InvokeBusyHandler(&pBt->db->busyHandler);
sl@0	1206	}
sl@0	1207
sl@0	1208	/*
sl@0	1209	** Open a database file.
sl@0	1210	**
sl@0	1211	** zFilename is the name of the database file. If zFilename is NULL
sl@0	1212	** a new database with a random name is created. This randomly named
sl@0	1213	** database file will be deleted when sqlite3BtreeClose() is called.
sl@0	1214	** If zFilename is ":memory:" then an in-memory database is created
sl@0	1215	** that is automatically destroyed when it is closed.
sl@0	1216	*/
sl@0	1217	int sqlite3BtreeOpen(
sl@0	1218	const char zFilename, / Name of the file containing the BTree database */
sl@0	1219	sqlite3 db, / Associated database handle */
sl@0	1220	Btree *ppBtree, / Pointer to new Btree object written here */
sl@0	1221	int flags, /* Options */
sl@0	1222	int vfsFlags /* Flags passed through to sqlite3_vfs.xOpen() */
sl@0	1223	){
sl@0	1224	sqlite3_vfs pVfs; / The VFS to use for this btree */
sl@0	1225	BtShared pBt = 0; / Shared part of btree structure */
sl@0	1226	Btree p; / Handle to return */
sl@0	1227	int rc = SQLITE_OK;
sl@0	1228	int nReserve;
sl@0	1229	unsigned char zDbHeader[100];
sl@0	1230
sl@0	1231	/* Set the variable isMemdb to true for an in-memory database, or
sl@0	1232	** false for a file-based database. This symbol is only required if
sl@0	1233	** either of the shared-data or autovacuum features are compiled
sl@0	1234	** into the library.
sl@0	1235	*/
sl@0	1236	#if !defined(SQLITE_OMIT_SHARED_CACHE) \|\| !defined(SQLITE_OMIT_AUTOVACUUM)
sl@0	1237	#ifdef SQLITE_OMIT_MEMORYDB
sl@0	1238	const int isMemdb = 0;
sl@0	1239	#else
sl@0	1240	const int isMemdb = zFilename && !strcmp(zFilename, ":memory:");
sl@0	1241	#endif
sl@0	1242	#endif
sl@0	1243
sl@0	1244	assert( db!=0 );
sl@0	1245	assert( sqlite3_mutex_held(db->mutex) );
sl@0	1246
sl@0	1247	pVfs = db->pVfs;
sl@0	1248	p = sqlite3MallocZero(sizeof(Btree));
sl@0	1249	if( !p ){
sl@0	1250	return SQLITE_NOMEM;
sl@0	1251	}
sl@0	1252	p->inTrans = TRANS_NONE;
sl@0	1253	p->db = db;
sl@0	1254
sl@0	1255	#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
sl@0	1256	/*
sl@0	1257	** If this Btree is a candidate for shared cache, try to find an
sl@0	1258	** existing BtShared object that we can share with
sl@0	1259	*/
sl@0	1260	if( isMemdb==0
sl@0	1261	&& (db->flags & SQLITE_Vtab)==0
sl@0	1262	&& zFilename && zFilename[0]
sl@0	1263	){
sl@0	1264	if( sqlite3GlobalConfig.sharedCacheEnabled ){
sl@0	1265	int nFullPathname = pVfs->mxPathname+1;
sl@0	1266	char *zFullPathname = sqlite3Malloc(nFullPathname);
sl@0	1267	sqlite3_mutex *mutexShared;
sl@0	1268	p->sharable = 1;
sl@0	1269	db->flags \|= SQLITE_SharedCache;
sl@0	1270	if( !zFullPathname ){
sl@0	1271	sqlite3_free(p);
sl@0	1272	return SQLITE_NOMEM;
sl@0	1273	}
sl@0	1274	sqlite3OsFullPathname(pVfs, zFilename, nFullPathname, zFullPathname);
sl@0	1275	mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0	1276	sqlite3_mutex_enter(mutexShared);
sl@0	1277	for(pBt=GLOBAL(BtShared*,sqlite3SharedCacheList); pBt; pBt=pBt->pNext){
sl@0	1278	assert( pBt->nRef>0 );
sl@0	1279	if( 0==strcmp(zFullPathname, sqlite3PagerFilename(pBt->pPager))
sl@0	1280	&& sqlite3PagerVfs(pBt->pPager)==pVfs ){
sl@0	1281	p->pBt = pBt;
sl@0	1282	pBt->nRef++;
sl@0	1283	break;
sl@0	1284	}
sl@0	1285	}
sl@0	1286	sqlite3_mutex_leave(mutexShared);
sl@0	1287	sqlite3_free(zFullPathname);
sl@0	1288	}
sl@0	1289	#ifdef SQLITE_DEBUG
sl@0	1290	else{
sl@0	1291	/* In debug mode, we mark all persistent databases as sharable
sl@0	1292	** even when they are not. This exercises the locking code and
sl@0	1293	** gives more opportunity for asserts(sqlite3_mutex_held())
sl@0	1294	** statements to find locking problems.
sl@0	1295	*/
sl@0	1296	p->sharable = 1;
sl@0	1297	}
sl@0	1298	#endif
sl@0	1299	}
sl@0	1300	#endif
sl@0	1301	if( pBt==0 ){
sl@0	1302	/*
sl@0	1303	** The following asserts make sure that structures used by the btree are
sl@0	1304	** the right size. This is to guard against size changes that result
sl@0	1305	** when compiling on a different architecture.
sl@0	1306	*/
sl@0	1307	assert( sizeof(i64)==8 \|\| sizeof(i64)==4 );
sl@0	1308	assert( sizeof(u64)==8 \|\| sizeof(u64)==4 );
sl@0	1309	assert( sizeof(u32)==4 );
sl@0	1310	assert( sizeof(u16)==2 );
sl@0	1311	assert( sizeof(Pgno)==4 );
sl@0	1312
sl@0	1313	pBt = sqlite3MallocZero( sizeof(*pBt) );
sl@0	1314	if( pBt==0 ){
sl@0	1315	rc = SQLITE_NOMEM;
sl@0	1316	goto btree_open_out;
sl@0	1317	}
sl@0	1318	pBt->busyHdr.xFunc = sqlite3BtreeInvokeBusyHandler;
sl@0	1319	pBt->busyHdr.pArg = pBt;
sl@0	1320	rc = sqlite3PagerOpen(pVfs, &pBt->pPager, zFilename,
sl@0	1321	EXTRA_SIZE, flags, vfsFlags);
sl@0	1322	if( rc==SQLITE_OK ){
sl@0	1323	rc = sqlite3PagerReadFileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
sl@0	1324	}
sl@0	1325	if( rc!=SQLITE_OK ){
sl@0	1326	goto btree_open_out;
sl@0	1327	}
sl@0	1328	sqlite3PagerSetBusyhandler(pBt->pPager, &pBt->busyHdr);
sl@0	1329	p->pBt = pBt;
sl@0	1330
sl@0	1331	sqlite3PagerSetReiniter(pBt->pPager, pageReinit);
sl@0	1332	pBt->pCursor = 0;
sl@0	1333	pBt->pPage1 = 0;
sl@0	1334	pBt->readOnly = sqlite3PagerIsreadonly(pBt->pPager);
sl@0	1335	pBt->pageSize = get2byte(&zDbHeader[16]);
sl@0	1336	if( pBt->pageSize<512 \|\| pBt->pageSize>SQLITE_MAX_PAGE_SIZE
sl@0	1337	\|\| ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
sl@0	1338	pBt->pageSize = 0;
sl@0	1339	sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
sl@0	1340	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	1341	/* If the magic name ":memory:" will create an in-memory database, then
sl@0	1342	** leave the autoVacuum mode at 0 (do not auto-vacuum), even if
sl@0	1343	** SQLITE_DEFAULT_AUTOVACUUM is true. On the other hand, if
sl@0	1344	** SQLITE_OMIT_MEMORYDB has been defined, then ":memory:" is just a
sl@0	1345	** regular file-name. In this case the auto-vacuum applies as per normal.
sl@0	1346	*/
sl@0	1347	if( zFilename && !isMemdb ){
sl@0	1348	pBt->autoVacuum = (SQLITE_DEFAULT_AUTOVACUUM ? 1 : 0);
sl@0	1349	pBt->incrVacuum = (SQLITE_DEFAULT_AUTOVACUUM==2 ? 1 : 0);
sl@0	1350	}
sl@0	1351	#endif
sl@0	1352	nReserve = 0;
sl@0	1353	}else{
sl@0	1354	nReserve = zDbHeader[20];
sl@0	1355	pBt->pageSizeFixed = 1;
sl@0	1356	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	1357	pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
sl@0	1358	pBt->incrVacuum = (get4byte(&zDbHeader[36 + 7*4])?1:0);
sl@0	1359	#endif
sl@0	1360	}
sl@0	1361	pBt->usableSize = pBt->pageSize - nReserve;
sl@0	1362	assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
sl@0	1363	sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
sl@0	1364
sl@0	1365	#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
sl@0	1366	/* Add the new BtShared object to the linked list sharable BtShareds.
sl@0	1367	*/
sl@0	1368	if( p->sharable ){
sl@0	1369	sqlite3_mutex *mutexShared;
sl@0	1370	pBt->nRef = 1;
sl@0	1371	mutexShared = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0	1372	if( SQLITE_THREADSAFE && sqlite3GlobalConfig.bCoreMutex ){
sl@0	1373	pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
sl@0	1374	if( pBt->mutex==0 ){
sl@0	1375	rc = SQLITE_NOMEM;
sl@0	1376	db->mallocFailed = 0;
sl@0	1377	goto btree_open_out;
sl@0	1378	}
sl@0	1379	}
sl@0	1380	sqlite3_mutex_enter(mutexShared);
sl@0	1381	pBt->pNext = GLOBAL(BtShared*,sqlite3SharedCacheList);
sl@0	1382	GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt;
sl@0	1383	sqlite3_mutex_leave(mutexShared);
sl@0	1384	}
sl@0	1385	#endif
sl@0	1386	}
sl@0	1387
sl@0	1388	#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
sl@0	1389	/* If the new Btree uses a sharable pBtShared, then link the new
sl@0	1390	** Btree into the list of all sharable Btrees for the same connection.
sl@0	1391	** The list is kept in ascending order by pBt address.
sl@0	1392	*/
sl@0	1393	if( p->sharable ){
sl@0	1394	int i;
sl@0	1395	Btree *pSib;
sl@0	1396	for(i=0; i<db->nDb; i++){
sl@0	1397	if( (pSib = db->aDb[i].pBt)!=0 && pSib->sharable ){
sl@0	1398	while( pSib->pPrev ){ pSib = pSib->pPrev; }
sl@0	1399	if( p->pBt<pSib->pBt ){
sl@0	1400	p->pNext = pSib;
sl@0	1401	p->pPrev = 0;
sl@0	1402	pSib->pPrev = p;
sl@0	1403	}else{
sl@0	1404	while( pSib->pNext && pSib->pNext->pBt<p->pBt ){
sl@0	1405	pSib = pSib->pNext;
sl@0	1406	}
sl@0	1407	p->pNext = pSib->pNext;
sl@0	1408	p->pPrev = pSib;
sl@0	1409	if( p->pNext ){
sl@0	1410	p->pNext->pPrev = p;
sl@0	1411	}
sl@0	1412	pSib->pNext = p;
sl@0	1413	}
sl@0	1414	break;
sl@0	1415	}
sl@0	1416	}
sl@0	1417	}
sl@0	1418	#endif
sl@0	1419	*ppBtree = p;
sl@0	1420
sl@0	1421	btree_open_out:
sl@0	1422	if( rc!=SQLITE_OK ){
sl@0	1423	if( pBt && pBt->pPager ){
sl@0	1424	sqlite3PagerClose(pBt->pPager);
sl@0	1425	}
sl@0	1426	sqlite3_free(pBt);
sl@0	1427	sqlite3_free(p);
sl@0	1428	*ppBtree = 0;
sl@0	1429	}
sl@0	1430	return rc;
sl@0	1431	}
sl@0	1432
sl@0	1433	/*
sl@0	1434	** Decrement the BtShared.nRef counter. When it reaches zero,
sl@0	1435	** remove the BtShared structure from the sharing list. Return
sl@0	1436	** true if the BtShared.nRef counter reaches zero and return
sl@0	1437	** false if it is still positive.
sl@0	1438	*/
sl@0	1439	static int removeFromSharingList(BtShared *pBt){
sl@0	1440	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	1441	sqlite3_mutex *pMaster;
sl@0	1442	BtShared *pList;
sl@0	1443	int removed = 0;
sl@0	1444
sl@0	1445	assert( sqlite3_mutex_notheld(pBt->mutex) );
sl@0	1446	pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
sl@0	1447	sqlite3_mutex_enter(pMaster);
sl@0	1448	pBt->nRef--;
sl@0	1449	if( pBt->nRef<=0 ){
sl@0	1450	if( GLOBAL(BtShared*,sqlite3SharedCacheList)==pBt ){
sl@0	1451	GLOBAL(BtShared*,sqlite3SharedCacheList) = pBt->pNext;
sl@0	1452	}else{
sl@0	1453	pList = GLOBAL(BtShared*,sqlite3SharedCacheList);
sl@0	1454	while( ALWAYS(pList) && pList->pNext!=pBt ){
sl@0	1455	pList=pList->pNext;
sl@0	1456	}
sl@0	1457	if( ALWAYS(pList) ){
sl@0	1458	pList->pNext = pBt->pNext;
sl@0	1459	}
sl@0	1460	}
sl@0	1461	if( SQLITE_THREADSAFE ){
sl@0	1462	sqlite3_mutex_free(pBt->mutex);
sl@0	1463	}
sl@0	1464	removed = 1;
sl@0	1465	}
sl@0	1466	sqlite3_mutex_leave(pMaster);
sl@0	1467	return removed;
sl@0	1468	#else
sl@0	1469	return 1;
sl@0	1470	#endif
sl@0	1471	}
sl@0	1472
sl@0	1473	/*
sl@0	1474	** Make sure pBt->pTmpSpace points to an allocation of
sl@0	1475	** MX_CELL_SIZE(pBt) bytes.
sl@0	1476	*/
sl@0	1477	static void allocateTempSpace(BtShared *pBt){
sl@0	1478	if( !pBt->pTmpSpace ){
sl@0	1479	pBt->pTmpSpace = sqlite3PageMalloc( pBt->pageSize );
sl@0	1480	}
sl@0	1481	}
sl@0	1482
sl@0	1483	/*
sl@0	1484	** Free the pBt->pTmpSpace allocation
sl@0	1485	*/
sl@0	1486	static void freeTempSpace(BtShared *pBt){
sl@0	1487	sqlite3PageFree( pBt->pTmpSpace);
sl@0	1488	pBt->pTmpSpace = 0;
sl@0	1489	}
sl@0	1490
sl@0	1491	/*
sl@0	1492	** Close an open database and invalidate all cursors.
sl@0	1493	*/
sl@0	1494	int sqlite3BtreeClose(Btree *p){
sl@0	1495	BtShared *pBt = p->pBt;
sl@0	1496	BtCursor *pCur;
sl@0	1497
sl@0	1498	/* Close all cursors opened via this handle. */
sl@0	1499	assert( sqlite3_mutex_held(p->db->mutex) );
sl@0	1500	sqlite3BtreeEnter(p);
sl@0	1501	pBt->db = p->db;
sl@0	1502	pCur = pBt->pCursor;
sl@0	1503	while( pCur ){
sl@0	1504	BtCursor *pTmp = pCur;
sl@0	1505	pCur = pCur->pNext;
sl@0	1506	if( pTmp->pBtree==p ){
sl@0	1507	sqlite3BtreeCloseCursor(pTmp);
sl@0	1508	}
sl@0	1509	}
sl@0	1510
sl@0	1511	/* Rollback any active transaction and free the handle structure.
sl@0	1512	** The call to sqlite3BtreeRollback() drops any table-locks held by
sl@0	1513	** this handle.
sl@0	1514	*/
sl@0	1515	sqlite3BtreeRollback(p);
sl@0	1516	sqlite3BtreeLeave(p);
sl@0	1517
sl@0	1518	/* If there are still other outstanding references to the shared-btree
sl@0	1519	** structure, return now. The remainder of this procedure cleans
sl@0	1520	** up the shared-btree.
sl@0	1521	*/
sl@0	1522	assert( p->wantToLock==0 && p->locked==0 );
sl@0	1523	if( !p->sharable \|\| removeFromSharingList(pBt) ){
sl@0	1524	/* The pBt is no longer on the sharing list, so we can access
sl@0	1525	** it without having to hold the mutex.
sl@0	1526	**
sl@0	1527	** Clean out and delete the BtShared object.
sl@0	1528	*/
sl@0	1529	assert( !pBt->pCursor );
sl@0	1530	sqlite3PagerClose(pBt->pPager);
sl@0	1531	if( pBt->xFreeSchema && pBt->pSchema ){
sl@0	1532	pBt->xFreeSchema(pBt->pSchema);
sl@0	1533	}
sl@0	1534	sqlite3_free(pBt->pSchema);
sl@0	1535	freeTempSpace(pBt);
sl@0	1536	sqlite3_free(pBt);
sl@0	1537	}
sl@0	1538
sl@0	1539	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	1540	assert( p->wantToLock==0 );
sl@0	1541	assert( p->locked==0 );
sl@0	1542	if( p->pPrev ) p->pPrev->pNext = p->pNext;
sl@0	1543	if( p->pNext ) p->pNext->pPrev = p->pPrev;
sl@0	1544	#endif
sl@0	1545
sl@0	1546	sqlite3_free(p);
sl@0	1547	return SQLITE_OK;
sl@0	1548	}
sl@0	1549
sl@0	1550	/*
sl@0	1551	** Change the limit on the number of pages allowed in the cache.
sl@0	1552	**
sl@0	1553	** The maximum number of cache pages is set to the absolute
sl@0	1554	** value of mxPage. If mxPage is negative, the pager will
sl@0	1555	** operate asynchronously - it will not stop to do fsync()s
sl@0	1556	** to insure data is written to the disk surface before
sl@0	1557	** continuing. Transactions still work if synchronous is off,
sl@0	1558	** and the database cannot be corrupted if this program
sl@0	1559	** crashes. But if the operating system crashes or there is
sl@0	1560	** an abrupt power failure when synchronous is off, the database
sl@0	1561	** could be left in an inconsistent and unrecoverable state.
sl@0	1562	** Synchronous is on by default so database corruption is not
sl@0	1563	** normally a worry.
sl@0	1564	*/
sl@0	1565	int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
sl@0	1566	BtShared *pBt = p->pBt;
sl@0	1567	assert( sqlite3_mutex_held(p->db->mutex) );
sl@0	1568	sqlite3BtreeEnter(p);
sl@0	1569	sqlite3PagerSetCachesize(pBt->pPager, mxPage);
sl@0	1570	sqlite3BtreeLeave(p);
sl@0	1571	return SQLITE_OK;
sl@0	1572	}
sl@0	1573
sl@0	1574	/*
sl@0	1575	** Change the way data is synced to disk in order to increase or decrease
sl@0	1576	** how well the database resists damage due to OS crashes and power
sl@0	1577	** failures. Level 1 is the same as asynchronous (no syncs() occur and
sl@0	1578	** there is a high probability of damage) Level 2 is the default. There
sl@0	1579	** is a very low but non-zero probability of damage. Level 3 reduces the
sl@0	1580	** probability of damage to near zero but with a write performance reduction.
sl@0	1581	*/
sl@0	1582	#ifndef SQLITE_OMIT_PAGER_PRAGMAS
sl@0	1583	int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){
sl@0	1584	BtShared *pBt = p->pBt;
sl@0	1585	assert( sqlite3_mutex_held(p->db->mutex) );
sl@0	1586	sqlite3BtreeEnter(p);
sl@0	1587	sqlite3PagerSetSafetyLevel(pBt->pPager, level, fullSync);
sl@0	1588	sqlite3BtreeLeave(p);
sl@0	1589	return SQLITE_OK;
sl@0	1590	}
sl@0	1591	#endif
sl@0	1592
sl@0	1593	/*
sl@0	1594	** Return TRUE if the given btree is set to safety level 1. In other
sl@0	1595	** words, return TRUE if no sync() occurs on the disk files.
sl@0	1596	*/
sl@0	1597	int sqlite3BtreeSyncDisabled(Btree *p){
sl@0	1598	BtShared *pBt = p->pBt;
sl@0	1599	int rc;
sl@0	1600	assert( sqlite3_mutex_held(p->db->mutex) );
sl@0	1601	sqlite3BtreeEnter(p);
sl@0	1602	assert( pBt && pBt->pPager );
sl@0	1603	rc = sqlite3PagerNosync(pBt->pPager);
sl@0	1604	sqlite3BtreeLeave(p);
sl@0	1605	return rc;
sl@0	1606	}
sl@0	1607
sl@0	1608	#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) \|\| !defined(SQLITE_OMIT_VACUUM)
sl@0	1609	/*
sl@0	1610	** Change the default pages size and the number of reserved bytes per page.
sl@0	1611	**
sl@0	1612	** The page size must be a power of 2 between 512 and 65536. If the page
sl@0	1613	** size supplied does not meet this constraint then the page size is not
sl@0	1614	** changed.
sl@0	1615	**
sl@0	1616	** Page sizes are constrained to be a power of two so that the region
sl@0	1617	** of the database file used for locking (beginning at PENDING_BYTE,
sl@0	1618	** the first byte past the 1GB boundary, 0x40000000) needs to occur
sl@0	1619	** at the beginning of a page.
sl@0	1620	**
sl@0	1621	** If parameter nReserve is less than zero, then the number of reserved
sl@0	1622	** bytes per page is left unchanged.
sl@0	1623	*/
sl@0	1624	int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){
sl@0	1625	int rc = SQLITE_OK;
sl@0	1626	BtShared *pBt = p->pBt;
sl@0	1627	sqlite3BtreeEnter(p);
sl@0	1628	if( pBt->pageSizeFixed ){
sl@0	1629	sqlite3BtreeLeave(p);
sl@0	1630	return SQLITE_READONLY;
sl@0	1631	}
sl@0	1632	if( nReserve<0 ){
sl@0	1633	nReserve = pBt->pageSize - pBt->usableSize;
sl@0	1634	}
sl@0	1635	if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
sl@0	1636	((pageSize-1)&pageSize)==0 ){
sl@0	1637	assert( (pageSize & 7)==0 );
sl@0	1638	assert( !pBt->pPage1 && !pBt->pCursor );
sl@0	1639	pBt->pageSize = pageSize;
sl@0	1640	freeTempSpace(pBt);
sl@0	1641	rc = sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
sl@0	1642	}
sl@0	1643	pBt->usableSize = pBt->pageSize - nReserve;
sl@0	1644	sqlite3BtreeLeave(p);
sl@0	1645	return rc;
sl@0	1646	}
sl@0	1647
sl@0	1648	/*
sl@0	1649	** Return the currently defined page size
sl@0	1650	*/
sl@0	1651	int sqlite3BtreeGetPageSize(Btree *p){
sl@0	1652	return p->pBt->pageSize;
sl@0	1653	}
sl@0	1654	int sqlite3BtreeGetReserve(Btree *p){
sl@0	1655	int n;
sl@0	1656	sqlite3BtreeEnter(p);
sl@0	1657	n = p->pBt->pageSize - p->pBt->usableSize;
sl@0	1658	sqlite3BtreeLeave(p);
sl@0	1659	return n;
sl@0	1660	}
sl@0	1661
sl@0	1662	/*
sl@0	1663	** Set the maximum page count for a database if mxPage is positive.
sl@0	1664	** No changes are made if mxPage is 0 or negative.
sl@0	1665	** Regardless of the value of mxPage, return the maximum page count.
sl@0	1666	*/
sl@0	1667	int sqlite3BtreeMaxPageCount(Btree *p, int mxPage){
sl@0	1668	int n;
sl@0	1669	sqlite3BtreeEnter(p);
sl@0	1670	n = sqlite3PagerMaxPageCount(p->pBt->pPager, mxPage);
sl@0	1671	sqlite3BtreeLeave(p);
sl@0	1672	return n;
sl@0	1673	}
sl@0	1674	#endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) \|\| !defined(SQLITE_OMIT_VACUUM) */
sl@0	1675
sl@0	1676	/*
sl@0	1677	** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
sl@0	1678	** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
sl@0	1679	** is disabled. The default value for the auto-vacuum property is
sl@0	1680	** determined by the SQLITE_DEFAULT_AUTOVACUUM macro.
sl@0	1681	*/
sl@0	1682	int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
sl@0	1683	#ifdef SQLITE_OMIT_AUTOVACUUM
sl@0	1684	return SQLITE_READONLY;
sl@0	1685	#else
sl@0	1686	BtShared *pBt = p->pBt;
sl@0	1687	int rc = SQLITE_OK;
sl@0	1688	int av = (autoVacuum?1:0);
sl@0	1689
sl@0	1690	sqlite3BtreeEnter(p);
sl@0	1691	if( pBt->pageSizeFixed && av!=pBt->autoVacuum ){
sl@0	1692	rc = SQLITE_READONLY;
sl@0	1693	}else{
sl@0	1694	pBt->autoVacuum = av;
sl@0	1695	}
sl@0	1696	sqlite3BtreeLeave(p);
sl@0	1697	return rc;
sl@0	1698	#endif
sl@0	1699	}
sl@0	1700
sl@0	1701	/*
sl@0	1702	** Return the value of the 'auto-vacuum' property. If auto-vacuum is
sl@0	1703	** enabled 1 is returned. Otherwise 0.
sl@0	1704	*/
sl@0	1705	int sqlite3BtreeGetAutoVacuum(Btree *p){
sl@0	1706	#ifdef SQLITE_OMIT_AUTOVACUUM
sl@0	1707	return BTREE_AUTOVACUUM_NONE;
sl@0	1708	#else
sl@0	1709	int rc;
sl@0	1710	sqlite3BtreeEnter(p);
sl@0	1711	rc = (
sl@0	1712	(!p->pBt->autoVacuum)?BTREE_AUTOVACUUM_NONE:
sl@0	1713	(!p->pBt->incrVacuum)?BTREE_AUTOVACUUM_FULL:
sl@0	1714	BTREE_AUTOVACUUM_INCR
sl@0	1715	);
sl@0	1716	sqlite3BtreeLeave(p);
sl@0	1717	return rc;
sl@0	1718	#endif
sl@0	1719	}
sl@0	1720
sl@0	1721
sl@0	1722	/*
sl@0	1723	** Get a reference to pPage1 of the database file. This will
sl@0	1724	** also acquire a readlock on that file.
sl@0	1725	**
sl@0	1726	** SQLITE_OK is returned on success. If the file is not a
sl@0	1727	** well-formed database file, then SQLITE_CORRUPT is returned.
sl@0	1728	** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
sl@0	1729	** is returned if we run out of memory.
sl@0	1730	*/
sl@0	1731	static int lockBtree(BtShared *pBt){
sl@0	1732	int rc;
sl@0	1733	MemPage *pPage1;
sl@0	1734	int nPage;
sl@0	1735
sl@0	1736	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	1737	if( pBt->pPage1 ) return SQLITE_OK;
sl@0	1738	rc = sqlite3BtreeGetPage(pBt, 1, &pPage1, 0);
sl@0	1739	if( rc!=SQLITE_OK ) return rc;
sl@0	1740
sl@0	1741	/* Do some checking to help insure the file we opened really is
sl@0	1742	** a valid database file.
sl@0	1743	*/
sl@0	1744	rc = sqlite3PagerPagecount(pBt->pPager, &nPage);
sl@0	1745	if( rc!=SQLITE_OK ){
sl@0	1746	goto page1_init_failed;
sl@0	1747	}else if( nPage>0 ){
sl@0	1748	int pageSize;
sl@0	1749	int usableSize;
sl@0	1750	u8 *page1 = pPage1->aData;
sl@0	1751	rc = SQLITE_NOTADB;
sl@0	1752	if( memcmp(page1, zMagicHeader, 16)!=0 ){
sl@0	1753	goto page1_init_failed;
sl@0	1754	}
sl@0	1755	if( page1[18]>1 ){
sl@0	1756	pBt->readOnly = 1;
sl@0	1757	}
sl@0	1758	if( page1[19]>1 ){
sl@0	1759	goto page1_init_failed;
sl@0	1760	}
sl@0	1761
sl@0	1762	/* The maximum embedded fraction must be exactly 25%. And the minimum
sl@0	1763	** embedded fraction must be 12.5% for both leaf-data and non-leaf-data.
sl@0	1764	** The original design allowed these amounts to vary, but as of
sl@0	1765	** version 3.6.0, we require them to be fixed.
sl@0	1766	*/
sl@0	1767	if( memcmp(&page1[21], "\100\040\040",3)!=0 ){
sl@0	1768	goto page1_init_failed;
sl@0	1769	}
sl@0	1770	pageSize = get2byte(&page1[16]);
sl@0	1771	if( ((pageSize-1)&pageSize)!=0 \|\| pageSize<512 \|\|
sl@0	1772	(SQLITE_MAX_PAGE_SIZE<32768 && pageSize>SQLITE_MAX_PAGE_SIZE)
sl@0	1773	){
sl@0	1774	goto page1_init_failed;
sl@0	1775	}
sl@0	1776	assert( (pageSize & 7)==0 );
sl@0	1777	usableSize = pageSize - page1[20];
sl@0	1778	if( pageSize!=pBt->pageSize ){
sl@0	1779	/* After reading the first page of the database assuming a page size
sl@0	1780	** of BtShared.pageSize, we have discovered that the page-size is
sl@0	1781	** actually pageSize. Unlock the database, leave pBt->pPage1 at
sl@0	1782	** zero and return SQLITE_OK. The caller will call this function
sl@0	1783	** again with the correct page-size.
sl@0	1784	*/
sl@0	1785	releasePage(pPage1);
sl@0	1786	pBt->usableSize = usableSize;
sl@0	1787	pBt->pageSize = pageSize;
sl@0	1788	freeTempSpace(pBt);
sl@0	1789	sqlite3PagerSetPagesize(pBt->pPager, &pBt->pageSize);
sl@0	1790	return SQLITE_OK;
sl@0	1791	}
sl@0	1792	if( usableSize<500 ){
sl@0	1793	goto page1_init_failed;
sl@0	1794	}
sl@0	1795	pBt->pageSize = pageSize;
sl@0	1796	pBt->usableSize = usableSize;
sl@0	1797	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	1798	pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
sl@0	1799	pBt->incrVacuum = (get4byte(&page1[36 + 7*4])?1:0);
sl@0	1800	#endif
sl@0	1801	}
sl@0	1802
sl@0	1803	/* maxLocal is the maximum amount of payload to store locally for
sl@0	1804	** a cell. Make sure it is small enough so that at least minFanout
sl@0	1805	** cells can will fit on one page. We assume a 10-byte page header.
sl@0	1806	** Besides the payload, the cell must store:
sl@0	1807	** 2-byte pointer to the cell
sl@0	1808	** 4-byte child pointer
sl@0	1809	** 9-byte nKey value
sl@0	1810	** 4-byte nData value
sl@0	1811	** 4-byte overflow page pointer
sl@0	1812	** So a cell consists of a 2-byte poiner, a header which is as much as
sl@0	1813	** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
sl@0	1814	** page pointer.
sl@0	1815	*/
sl@0	1816	pBt->maxLocal = (pBt->usableSize-12)*64/255 - 23;
sl@0	1817	pBt->minLocal = (pBt->usableSize-12)*32/255 - 23;
sl@0	1818	pBt->maxLeaf = pBt->usableSize - 35;
sl@0	1819	pBt->minLeaf = (pBt->usableSize-12)*32/255 - 23;
sl@0	1820	assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
sl@0	1821	pBt->pPage1 = pPage1;
sl@0	1822	return SQLITE_OK;
sl@0	1823
sl@0	1824	page1_init_failed:
sl@0	1825	releasePage(pPage1);
sl@0	1826	pBt->pPage1 = 0;
sl@0	1827	return rc;
sl@0	1828	}
sl@0	1829
sl@0	1830	/*
sl@0	1831	** This routine works like lockBtree() except that it also invokes the
sl@0	1832	** busy callback if there is lock contention.
sl@0	1833	*/
sl@0	1834	static int lockBtreeWithRetry(Btree *pRef){
sl@0	1835	int rc = SQLITE_OK;
sl@0	1836
sl@0	1837	assert( sqlite3BtreeHoldsMutex(pRef) );
sl@0	1838	if( pRef->inTrans==TRANS_NONE ){
sl@0	1839	u8 inTransaction = pRef->pBt->inTransaction;
sl@0	1840	btreeIntegrity(pRef);
sl@0	1841	rc = sqlite3BtreeBeginTrans(pRef, 0);
sl@0	1842	pRef->pBt->inTransaction = inTransaction;
sl@0	1843	pRef->inTrans = TRANS_NONE;
sl@0	1844	if( rc==SQLITE_OK ){
sl@0	1845	pRef->pBt->nTransaction--;
sl@0	1846	}
sl@0	1847	btreeIntegrity(pRef);
sl@0	1848	}
sl@0	1849	return rc;
sl@0	1850	}
sl@0	1851
sl@0	1852
sl@0	1853	/*
sl@0	1854	** If there are no outstanding cursors and we are not in the middle
sl@0	1855	** of a transaction but there is a read lock on the database, then
sl@0	1856	** this routine unrefs the first page of the database file which
sl@0	1857	** has the effect of releasing the read lock.
sl@0	1858	**
sl@0	1859	** If there are any outstanding cursors, this routine is a no-op.
sl@0	1860	**
sl@0	1861	** If there is a transaction in progress, this routine is a no-op.
sl@0	1862	*/
sl@0	1863	static void unlockBtreeIfUnused(BtShared *pBt){
sl@0	1864	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	1865	if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){
sl@0	1866	if( sqlite3PagerRefcount(pBt->pPager)>=1 ){
sl@0	1867	assert( pBt->pPage1->aData );
sl@0	1868	#if 0
sl@0	1869	if( pBt->pPage1->aData==0 ){
sl@0	1870	MemPage *pPage = pBt->pPage1;
sl@0	1871	pPage->aData = sqlite3PagerGetData(pPage->pDbPage);
sl@0	1872	pPage->pBt = pBt;
sl@0	1873	pPage->pgno = 1;
sl@0	1874	}
sl@0	1875	#endif
sl@0	1876	releasePage(pBt->pPage1);
sl@0	1877	}
sl@0	1878	pBt->pPage1 = 0;
sl@0	1879	pBt->inStmt = 0;
sl@0	1880	}
sl@0	1881	}
sl@0	1882
sl@0	1883	/*
sl@0	1884	** Create a new database by initializing the first page of the
sl@0	1885	** file.
sl@0	1886	*/
sl@0	1887	static int newDatabase(BtShared *pBt){
sl@0	1888	MemPage *pP1;
sl@0	1889	unsigned char *data;
sl@0	1890	int rc;
sl@0	1891	int nPage;
sl@0	1892
sl@0	1893	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	1894	rc = sqlite3PagerPagecount(pBt->pPager, &nPage);
sl@0	1895	if( rc!=SQLITE_OK \|\| nPage>0 ){
sl@0	1896	return rc;
sl@0	1897	}
sl@0	1898	pP1 = pBt->pPage1;
sl@0	1899	assert( pP1!=0 );
sl@0	1900	data = pP1->aData;
sl@0	1901	rc = sqlite3PagerWrite(pP1->pDbPage);
sl@0	1902	if( rc ) return rc;
sl@0	1903	memcpy(data, zMagicHeader, sizeof(zMagicHeader));
sl@0	1904	assert( sizeof(zMagicHeader)==16 );
sl@0	1905	put2byte(&data[16], pBt->pageSize);
sl@0	1906	data[18] = 1;
sl@0	1907	data[19] = 1;
sl@0	1908	data[20] = pBt->pageSize - pBt->usableSize;
sl@0	1909	data[21] = 64;
sl@0	1910	data[22] = 32;
sl@0	1911	data[23] = 32;
sl@0	1912	memset(&data[24], 0, 100-24);
sl@0	1913	zeroPage(pP1, PTF_INTKEY\|PTF_LEAF\|PTF_LEAFDATA );
sl@0	1914	pBt->pageSizeFixed = 1;
sl@0	1915	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	1916	assert( pBt->autoVacuum==1 \|\| pBt->autoVacuum==0 );
sl@0	1917	assert( pBt->incrVacuum==1 \|\| pBt->incrVacuum==0 );
sl@0	1918	put4byte(&data[36 + 4*4], pBt->autoVacuum);
sl@0	1919	put4byte(&data[36 + 7*4], pBt->incrVacuum);
sl@0	1920	#endif
sl@0	1921	return SQLITE_OK;
sl@0	1922	}
sl@0	1923
sl@0	1924	/*
sl@0	1925	** Attempt to start a new transaction. A write-transaction
sl@0	1926	** is started if the second argument is nonzero, otherwise a read-
sl@0	1927	** transaction. If the second argument is 2 or more and exclusive
sl@0	1928	** transaction is started, meaning that no other process is allowed
sl@0	1929	** to access the database. A preexisting transaction may not be
sl@0	1930	** upgraded to exclusive by calling this routine a second time - the
sl@0	1931	** exclusivity flag only works for a new transaction.
sl@0	1932	**
sl@0	1933	** A write-transaction must be started before attempting any
sl@0	1934	** changes to the database. None of the following routines
sl@0	1935	** will work unless a transaction is started first:
sl@0	1936	**
sl@0	1937	** sqlite3BtreeCreateTable()
sl@0	1938	** sqlite3BtreeCreateIndex()
sl@0	1939	** sqlite3BtreeClearTable()
sl@0	1940	** sqlite3BtreeDropTable()
sl@0	1941	** sqlite3BtreeInsert()
sl@0	1942	** sqlite3BtreeDelete()
sl@0	1943	** sqlite3BtreeUpdateMeta()
sl@0	1944	**
sl@0	1945	** If an initial attempt to acquire the lock fails because of lock contention
sl@0	1946	** and the database was previously unlocked, then invoke the busy handler
sl@0	1947	** if there is one. But if there was previously a read-lock, do not
sl@0	1948	** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
sl@0	1949	** returned when there is already a read-lock in order to avoid a deadlock.
sl@0	1950	**
sl@0	1951	** Suppose there are two processes A and B. A has a read lock and B has
sl@0	1952	** a reserved lock. B tries to promote to exclusive but is blocked because
sl@0	1953	** of A's read lock. A tries to promote to reserved but is blocked by B.
sl@0	1954	** One or the other of the two processes must give way or there can be
sl@0	1955	** no progress. By returning SQLITE_BUSY and not invoking the busy callback
sl@0	1956	** when A already has a read lock, we encourage A to give up and let B
sl@0	1957	** proceed.
sl@0	1958	*/
sl@0	1959	int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
sl@0	1960	BtShared *pBt = p->pBt;
sl@0	1961	int rc = SQLITE_OK;
sl@0	1962
sl@0	1963	sqlite3BtreeEnter(p);
sl@0	1964	pBt->db = p->db;
sl@0	1965	btreeIntegrity(p);
sl@0	1966
sl@0	1967	/* If the btree is already in a write-transaction, or it
sl@0	1968	** is already in a read-transaction and a read-transaction
sl@0	1969	** is requested, this is a no-op.
sl@0	1970	*/
sl@0	1971	if( p->inTrans==TRANS_WRITE \|\| (p->inTrans==TRANS_READ && !wrflag) ){
sl@0	1972	goto trans_begun;
sl@0	1973	}
sl@0	1974
sl@0	1975	/* Write transactions are not possible on a read-only database */
sl@0	1976	if( pBt->readOnly && wrflag ){
sl@0	1977	rc = SQLITE_READONLY;
sl@0	1978	goto trans_begun;
sl@0	1979	}
sl@0	1980
sl@0	1981	/* If another database handle has already opened a write transaction
sl@0	1982	** on this shared-btree structure and a second write transaction is
sl@0	1983	** requested, return SQLITE_BUSY.
sl@0	1984	*/
sl@0	1985	if( pBt->inTransaction==TRANS_WRITE && wrflag ){
sl@0	1986	rc = SQLITE_BUSY;
sl@0	1987	goto trans_begun;
sl@0	1988	}
sl@0	1989
sl@0	1990	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	1991	if( wrflag>1 ){
sl@0	1992	BtLock *pIter;
sl@0	1993	for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
sl@0	1994	if( pIter->pBtree!=p ){
sl@0	1995	rc = SQLITE_BUSY;
sl@0	1996	goto trans_begun;
sl@0	1997	}
sl@0	1998	}
sl@0	1999	}
sl@0	2000	#endif
sl@0	2001
sl@0	2002	do {
sl@0	2003	if( pBt->pPage1==0 ){
sl@0	2004	do{
sl@0	2005	rc = lockBtree(pBt);
sl@0	2006	}while( pBt->pPage1==0 && rc==SQLITE_OK );
sl@0	2007	}
sl@0	2008
sl@0	2009	if( rc==SQLITE_OK && wrflag ){
sl@0	2010	if( pBt->readOnly ){
sl@0	2011	rc = SQLITE_READONLY;
sl@0	2012	}else{
sl@0	2013	rc = sqlite3PagerBegin(pBt->pPage1->pDbPage, wrflag>1);
sl@0	2014	if( rc==SQLITE_OK ){
sl@0	2015	rc = newDatabase(pBt);
sl@0	2016	}
sl@0	2017	}
sl@0	2018	}
sl@0	2019
sl@0	2020	if( rc==SQLITE_OK ){
sl@0	2021	if( wrflag ) pBt->inStmt = 0;
sl@0	2022	}else{
sl@0	2023	unlockBtreeIfUnused(pBt);
sl@0	2024	}
sl@0	2025	}while( rc==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
sl@0	2026	sqlite3BtreeInvokeBusyHandler(pBt, 0) );
sl@0	2027
sl@0	2028	if( rc==SQLITE_OK ){
sl@0	2029	if( p->inTrans==TRANS_NONE ){
sl@0	2030	pBt->nTransaction++;
sl@0	2031	}
sl@0	2032	p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
sl@0	2033	if( p->inTrans>pBt->inTransaction ){
sl@0	2034	pBt->inTransaction = p->inTrans;
sl@0	2035	}
sl@0	2036	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	2037	if( wrflag>1 ){
sl@0	2038	assert( !pBt->pExclusive );
sl@0	2039	pBt->pExclusive = p;
sl@0	2040	}
sl@0	2041	#endif
sl@0	2042	}
sl@0	2043
sl@0	2044
sl@0	2045	trans_begun:
sl@0	2046	btreeIntegrity(p);
sl@0	2047	sqlite3BtreeLeave(p);
sl@0	2048	return rc;
sl@0	2049	}
sl@0	2050
sl@0	2051
sl@0	2052	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	2053
sl@0	2054	/*
sl@0	2055	** Set the pointer-map entries for all children of page pPage. Also, if
sl@0	2056	** pPage contains cells that point to overflow pages, set the pointer
sl@0	2057	** map entries for the overflow pages as well.
sl@0	2058	*/
sl@0	2059	static int setChildPtrmaps(MemPage *pPage){
sl@0	2060	int i; /* Counter variable */
sl@0	2061	int nCell; /* Number of cells in page pPage */
sl@0	2062	int rc; /* Return code */
sl@0	2063	BtShared *pBt = pPage->pBt;
sl@0	2064	int isInitOrig = pPage->isInit;
sl@0	2065	Pgno pgno = pPage->pgno;
sl@0	2066
sl@0	2067	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	2068	rc = sqlite3BtreeInitPage(pPage);
sl@0	2069	if( rc!=SQLITE_OK ){
sl@0	2070	goto set_child_ptrmaps_out;
sl@0	2071	}
sl@0	2072	nCell = pPage->nCell;
sl@0	2073
sl@0	2074	for(i=0; i<nCell; i++){
sl@0	2075	u8 *pCell = findCell(pPage, i);
sl@0	2076
sl@0	2077	rc = ptrmapPutOvflPtr(pPage, pCell);
sl@0	2078	if( rc!=SQLITE_OK ){
sl@0	2079	goto set_child_ptrmaps_out;
sl@0	2080	}
sl@0	2081
sl@0	2082	if( !pPage->leaf ){
sl@0	2083	Pgno childPgno = get4byte(pCell);
sl@0	2084	rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno);
sl@0	2085	if( rc!=SQLITE_OK ) goto set_child_ptrmaps_out;
sl@0	2086	}
sl@0	2087	}
sl@0	2088
sl@0	2089	if( !pPage->leaf ){
sl@0	2090	Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
sl@0	2091	rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno);
sl@0	2092	}
sl@0	2093
sl@0	2094	set_child_ptrmaps_out:
sl@0	2095	pPage->isInit = isInitOrig;
sl@0	2096	return rc;
sl@0	2097	}
sl@0	2098
sl@0	2099	/*
sl@0	2100	** Somewhere on pPage, which is guarenteed to be a btree page, not an overflow
sl@0	2101	** page, is a pointer to page iFrom. Modify this pointer so that it points to
sl@0	2102	** iTo. Parameter eType describes the type of pointer to be modified, as
sl@0	2103	** follows:
sl@0	2104	**
sl@0	2105	** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
sl@0	2106	** page of pPage.
sl@0	2107	**
sl@0	2108	** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
sl@0	2109	** page pointed to by one of the cells on pPage.
sl@0	2110	**
sl@0	2111	** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
sl@0	2112	** overflow page in the list.
sl@0	2113	*/
sl@0	2114	static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
sl@0	2115	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	2116	if( eType==PTRMAP_OVERFLOW2 ){
sl@0	2117	/* The pointer is always the first 4 bytes of the page in this case. */
sl@0	2118	if( get4byte(pPage->aData)!=iFrom ){
sl@0	2119	return SQLITE_CORRUPT_BKPT;
sl@0	2120	}
sl@0	2121	put4byte(pPage->aData, iTo);
sl@0	2122	}else{
sl@0	2123	int isInitOrig = pPage->isInit;
sl@0	2124	int i;
sl@0	2125	int nCell;
sl@0	2126
sl@0	2127	sqlite3BtreeInitPage(pPage);
sl@0	2128	nCell = pPage->nCell;
sl@0	2129
sl@0	2130	for(i=0; i<nCell; i++){
sl@0	2131	u8 *pCell = findCell(pPage, i);
sl@0	2132	if( eType==PTRMAP_OVERFLOW1 ){
sl@0	2133	CellInfo info;
sl@0	2134	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	2135	if( info.iOverflow ){
sl@0	2136	if( iFrom==get4byte(&pCell[info.iOverflow]) ){
sl@0	2137	put4byte(&pCell[info.iOverflow], iTo);
sl@0	2138	break;
sl@0	2139	}
sl@0	2140	}
sl@0	2141	}else{
sl@0	2142	if( get4byte(pCell)==iFrom ){
sl@0	2143	put4byte(pCell, iTo);
sl@0	2144	break;
sl@0	2145	}
sl@0	2146	}
sl@0	2147	}
sl@0	2148
sl@0	2149	if( i==nCell ){
sl@0	2150	if( eType!=PTRMAP_BTREE \|\|
sl@0	2151	get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
sl@0	2152	return SQLITE_CORRUPT_BKPT;
sl@0	2153	}
sl@0	2154	put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
sl@0	2155	}
sl@0	2156
sl@0	2157	pPage->isInit = isInitOrig;
sl@0	2158	}
sl@0	2159	return SQLITE_OK;
sl@0	2160	}
sl@0	2161
sl@0	2162
sl@0	2163	/*
sl@0	2164	** Move the open database page pDbPage to location iFreePage in the
sl@0	2165	** database. The pDbPage reference remains valid.
sl@0	2166	*/
sl@0	2167	static int relocatePage(
sl@0	2168	BtShared pBt, / Btree */
sl@0	2169	MemPage pDbPage, / Open page to move */
sl@0	2170	u8 eType, /* Pointer map 'type' entry for pDbPage */
sl@0	2171	Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
sl@0	2172	Pgno iFreePage, /* The location to move pDbPage to */
sl@0	2173	int isCommit
sl@0	2174	){
sl@0	2175	MemPage pPtrPage; / The page that contains a pointer to pDbPage */
sl@0	2176	Pgno iDbPage = pDbPage->pgno;
sl@0	2177	Pager *pPager = pBt->pPager;
sl@0	2178	int rc;
sl@0	2179
sl@0	2180	assert( eType==PTRMAP_OVERFLOW2 \|\| eType==PTRMAP_OVERFLOW1 \|\|
sl@0	2181	eType==PTRMAP_BTREE \|\| eType==PTRMAP_ROOTPAGE );
sl@0	2182	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	2183	assert( pDbPage->pBt==pBt );
sl@0	2184
sl@0	2185	/* Move page iDbPage from its current location to page number iFreePage */
sl@0	2186	TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
sl@0	2187	iDbPage, iFreePage, iPtrPage, eType));
sl@0	2188	rc = sqlite3PagerMovepage(pPager, pDbPage->pDbPage, iFreePage, isCommit);
sl@0	2189	if( rc!=SQLITE_OK ){
sl@0	2190	return rc;
sl@0	2191	}
sl@0	2192	pDbPage->pgno = iFreePage;
sl@0	2193
sl@0	2194	/* If pDbPage was a btree-page, then it may have child pages and/or cells
sl@0	2195	** that point to overflow pages. The pointer map entries for all these
sl@0	2196	** pages need to be changed.
sl@0	2197	**
sl@0	2198	** If pDbPage is an overflow page, then the first 4 bytes may store a
sl@0	2199	** pointer to a subsequent overflow page. If this is the case, then
sl@0	2200	** the pointer map needs to be updated for the subsequent overflow page.
sl@0	2201	*/
sl@0	2202	if( eType==PTRMAP_BTREE \|\| eType==PTRMAP_ROOTPAGE ){
sl@0	2203	rc = setChildPtrmaps(pDbPage);
sl@0	2204	if( rc!=SQLITE_OK ){
sl@0	2205	return rc;
sl@0	2206	}
sl@0	2207	}else{
sl@0	2208	Pgno nextOvfl = get4byte(pDbPage->aData);
sl@0	2209	if( nextOvfl!=0 ){
sl@0	2210	rc = ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage);
sl@0	2211	if( rc!=SQLITE_OK ){
sl@0	2212	return rc;
sl@0	2213	}
sl@0	2214	}
sl@0	2215	}
sl@0	2216
sl@0	2217	/* Fix the database pointer on page iPtrPage that pointed at iDbPage so
sl@0	2218	** that it points at iFreePage. Also fix the pointer map entry for
sl@0	2219	** iPtrPage.
sl@0	2220	*/
sl@0	2221	if( eType!=PTRMAP_ROOTPAGE ){
sl@0	2222	rc = sqlite3BtreeGetPage(pBt, iPtrPage, &pPtrPage, 0);
sl@0	2223	if( rc!=SQLITE_OK ){
sl@0	2224	return rc;
sl@0	2225	}
sl@0	2226	rc = sqlite3PagerWrite(pPtrPage->pDbPage);
sl@0	2227	if( rc!=SQLITE_OK ){
sl@0	2228	releasePage(pPtrPage);
sl@0	2229	return rc;
sl@0	2230	}
sl@0	2231	rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
sl@0	2232	releasePage(pPtrPage);
sl@0	2233	if( rc==SQLITE_OK ){
sl@0	2234	rc = ptrmapPut(pBt, iFreePage, eType, iPtrPage);
sl@0	2235	}
sl@0	2236	}
sl@0	2237	return rc;
sl@0	2238	}
sl@0	2239
sl@0	2240	/* Forward declaration required by incrVacuumStep(). */
sl@0	2241	static int allocateBtreePage(BtShared , MemPage , Pgno , Pgno, u8);
sl@0	2242
sl@0	2243	/*
sl@0	2244	** Perform a single step of an incremental-vacuum. If successful,
sl@0	2245	** return SQLITE_OK. If there is no work to do (and therefore no
sl@0	2246	** point in calling this function again), return SQLITE_DONE.
sl@0	2247	**
sl@0	2248	** More specificly, this function attempts to re-organize the
sl@0	2249	** database so that the last page of the file currently in use
sl@0	2250	** is no longer in use.
sl@0	2251	**
sl@0	2252	** If the nFin parameter is non-zero, the implementation assumes
sl@0	2253	** that the caller will keep calling incrVacuumStep() until
sl@0	2254	** it returns SQLITE_DONE or an error, and that nFin is the
sl@0	2255	** number of pages the database file will contain after this
sl@0	2256	** process is complete.
sl@0	2257	*/
sl@0	2258	static int incrVacuumStep(BtShared *pBt, Pgno nFin){
sl@0	2259	Pgno iLastPg; /* Last page in the database */
sl@0	2260	Pgno nFreeList; /* Number of pages still on the free-list */
sl@0	2261
sl@0	2262	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	2263	iLastPg = pBt->nTrunc;
sl@0	2264	if( iLastPg==0 ){
sl@0	2265	iLastPg = pagerPagecount(pBt->pPager);
sl@0	2266	}
sl@0	2267
sl@0	2268	if( !PTRMAP_ISPAGE(pBt, iLastPg) && iLastPg!=PENDING_BYTE_PAGE(pBt) ){
sl@0	2269	int rc;
sl@0	2270	u8 eType;
sl@0	2271	Pgno iPtrPage;
sl@0	2272
sl@0	2273	nFreeList = get4byte(&pBt->pPage1->aData[36]);
sl@0	2274	if( nFreeList==0 \|\| nFin==iLastPg ){
sl@0	2275	return SQLITE_DONE;
sl@0	2276	}
sl@0	2277
sl@0	2278	rc = ptrmapGet(pBt, iLastPg, &eType, &iPtrPage);
sl@0	2279	if( rc!=SQLITE_OK ){
sl@0	2280	return rc;
sl@0	2281	}
sl@0	2282	if( eType==PTRMAP_ROOTPAGE ){
sl@0	2283	return SQLITE_CORRUPT_BKPT;
sl@0	2284	}
sl@0	2285
sl@0	2286	if( eType==PTRMAP_FREEPAGE ){
sl@0	2287	if( nFin==0 ){
sl@0	2288	/* Remove the page from the files free-list. This is not required
sl@0	2289	** if nFin is non-zero. In that case, the free-list will be
sl@0	2290	** truncated to zero after this function returns, so it doesn't
sl@0	2291	** matter if it still contains some garbage entries.
sl@0	2292	*/
sl@0	2293	Pgno iFreePg;
sl@0	2294	MemPage *pFreePg;
sl@0	2295	rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, iLastPg, 1);
sl@0	2296	if( rc!=SQLITE_OK ){
sl@0	2297	return rc;
sl@0	2298	}
sl@0	2299	assert( iFreePg==iLastPg );
sl@0	2300	releasePage(pFreePg);
sl@0	2301	}
sl@0	2302	} else {
sl@0	2303	Pgno iFreePg; /* Index of free page to move pLastPg to */
sl@0	2304	MemPage *pLastPg;
sl@0	2305
sl@0	2306	rc = sqlite3BtreeGetPage(pBt, iLastPg, &pLastPg, 0);
sl@0	2307	if( rc!=SQLITE_OK ){
sl@0	2308	return rc;
sl@0	2309	}
sl@0	2310
sl@0	2311	/* If nFin is zero, this loop runs exactly once and page pLastPg
sl@0	2312	** is swapped with the first free page pulled off the free list.
sl@0	2313	**
sl@0	2314	** On the other hand, if nFin is greater than zero, then keep
sl@0	2315	** looping until a free-page located within the first nFin pages
sl@0	2316	** of the file is found.
sl@0	2317	*/
sl@0	2318	do {
sl@0	2319	MemPage *pFreePg;
sl@0	2320	rc = allocateBtreePage(pBt, &pFreePg, &iFreePg, 0, 0);
sl@0	2321	if( rc!=SQLITE_OK ){
sl@0	2322	releasePage(pLastPg);
sl@0	2323	return rc;
sl@0	2324	}
sl@0	2325	releasePage(pFreePg);
sl@0	2326	}while( nFin!=0 && iFreePg>nFin );
sl@0	2327	assert( iFreePg<iLastPg );
sl@0	2328
sl@0	2329	rc = sqlite3PagerWrite(pLastPg->pDbPage);
sl@0	2330	if( rc==SQLITE_OK ){
sl@0	2331	rc = relocatePage(pBt, pLastPg, eType, iPtrPage, iFreePg, nFin!=0);
sl@0	2332	}
sl@0	2333	releasePage(pLastPg);
sl@0	2334	if( rc!=SQLITE_OK ){
sl@0	2335	return rc;
sl@0	2336	}
sl@0	2337	}
sl@0	2338	}
sl@0	2339
sl@0	2340	pBt->nTrunc = iLastPg - 1;
sl@0	2341	while( pBt->nTrunc==PENDING_BYTE_PAGE(pBt)\|\|PTRMAP_ISPAGE(pBt, pBt->nTrunc) ){
sl@0	2342	pBt->nTrunc--;
sl@0	2343	}
sl@0	2344	return SQLITE_OK;
sl@0	2345	}
sl@0	2346
sl@0	2347	/*
sl@0	2348	** A write-transaction must be opened before calling this function.
sl@0	2349	** It performs a single unit of work towards an incremental vacuum.
sl@0	2350	**
sl@0	2351	** If the incremental vacuum is finished after this function has run,
sl@0	2352	** SQLITE_DONE is returned. If it is not finished, but no error occured,
sl@0	2353	** SQLITE_OK is returned. Otherwise an SQLite error code.
sl@0	2354	*/
sl@0	2355	int sqlite3BtreeIncrVacuum(Btree *p){
sl@0	2356	int rc;
sl@0	2357	BtShared *pBt = p->pBt;
sl@0	2358
sl@0	2359	sqlite3BtreeEnter(p);
sl@0	2360	pBt->db = p->db;
sl@0	2361	assert( pBt->inTransaction==TRANS_WRITE && p->inTrans==TRANS_WRITE );
sl@0	2362	if( !pBt->autoVacuum ){
sl@0	2363	rc = SQLITE_DONE;
sl@0	2364	}else{
sl@0	2365	invalidateAllOverflowCache(pBt);
sl@0	2366	rc = incrVacuumStep(pBt, 0);
sl@0	2367	}
sl@0	2368	sqlite3BtreeLeave(p);
sl@0	2369	return rc;
sl@0	2370	}
sl@0	2371
sl@0	2372	/*
sl@0	2373	** This routine is called prior to sqlite3PagerCommit when a transaction
sl@0	2374	** is commited for an auto-vacuum database.
sl@0	2375	**
sl@0	2376	** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages
sl@0	2377	** the database file should be truncated to during the commit process.
sl@0	2378	** i.e. the database has been reorganized so that only the first *pnTrunc
sl@0	2379	** pages are in use.
sl@0	2380	*/
sl@0	2381	static int autoVacuumCommit(BtShared pBt, Pgno pnTrunc){
sl@0	2382	int rc = SQLITE_OK;
sl@0	2383	Pager *pPager = pBt->pPager;
sl@0	2384	VVA_ONLY( int nRef = sqlite3PagerRefcount(pPager) );
sl@0	2385
sl@0	2386	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	2387	invalidateAllOverflowCache(pBt);
sl@0	2388	assert(pBt->autoVacuum);
sl@0	2389	if( !pBt->incrVacuum ){
sl@0	2390	Pgno nFin = 0;
sl@0	2391
sl@0	2392	if( pBt->nTrunc==0 ){
sl@0	2393	Pgno nFree;
sl@0	2394	Pgno nPtrmap;
sl@0	2395	const int pgsz = pBt->pageSize;
sl@0	2396	int nOrig = pagerPagecount(pBt->pPager);
sl@0	2397
sl@0	2398	if( PTRMAP_ISPAGE(pBt, nOrig) ){
sl@0	2399	return SQLITE_CORRUPT_BKPT;
sl@0	2400	}
sl@0	2401	if( nOrig==PENDING_BYTE_PAGE(pBt) ){
sl@0	2402	nOrig--;
sl@0	2403	}
sl@0	2404	nFree = get4byte(&pBt->pPage1->aData[36]);
sl@0	2405	nPtrmap = (nFree-nOrig+PTRMAP_PAGENO(pBt, nOrig)+pgsz/5)/(pgsz/5);
sl@0	2406	nFin = nOrig - nFree - nPtrmap;
sl@0	2407	if( nOrig>PENDING_BYTE_PAGE(pBt) && nFin<=PENDING_BYTE_PAGE(pBt) ){
sl@0	2408	nFin--;
sl@0	2409	}
sl@0	2410	while( PTRMAP_ISPAGE(pBt, nFin) \|\| nFin==PENDING_BYTE_PAGE(pBt) ){
sl@0	2411	nFin--;
sl@0	2412	}
sl@0	2413	}
sl@0	2414
sl@0	2415	while( rc==SQLITE_OK ){
sl@0	2416	rc = incrVacuumStep(pBt, nFin);
sl@0	2417	}
sl@0	2418	if( rc==SQLITE_DONE ){
sl@0	2419	assert(nFin==0 \|\| pBt->nTrunc==0 \|\| nFin<=pBt->nTrunc);
sl@0	2420	rc = SQLITE_OK;
sl@0	2421	if( pBt->nTrunc && nFin ){
sl@0	2422	rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
sl@0	2423	put4byte(&pBt->pPage1->aData[32], 0);
sl@0	2424	put4byte(&pBt->pPage1->aData[36], 0);
sl@0	2425	pBt->nTrunc = nFin;
sl@0	2426	}
sl@0	2427	}
sl@0	2428	if( rc!=SQLITE_OK ){
sl@0	2429	sqlite3PagerRollback(pPager);
sl@0	2430	}
sl@0	2431	}
sl@0	2432
sl@0	2433	if( rc==SQLITE_OK ){
sl@0	2434	*pnTrunc = pBt->nTrunc;
sl@0	2435	pBt->nTrunc = 0;
sl@0	2436	}
sl@0	2437	assert( nRef==sqlite3PagerRefcount(pPager) );
sl@0	2438	return rc;
sl@0	2439	}
sl@0	2440
sl@0	2441	#endif
sl@0	2442
sl@0	2443	/*
sl@0	2444	** This routine does the first phase of a two-phase commit. This routine
sl@0	2445	** causes a rollback journal to be created (if it does not already exist)
sl@0	2446	** and populated with enough information so that if a power loss occurs
sl@0	2447	** the database can be restored to its original state by playing back
sl@0	2448	** the journal. Then the contents of the journal are flushed out to
sl@0	2449	** the disk. After the journal is safely on oxide, the changes to the
sl@0	2450	** database are written into the database file and flushed to oxide.
sl@0	2451	** At the end of this call, the rollback journal still exists on the
sl@0	2452	** disk and we are still holding all locks, so the transaction has not
sl@0	2453	** committed. See sqlite3BtreeCommit() for the second phase of the
sl@0	2454	** commit process.
sl@0	2455	**
sl@0	2456	** This call is a no-op if no write-transaction is currently active on pBt.
sl@0	2457	**
sl@0	2458	** Otherwise, sync the database file for the btree pBt. zMaster points to
sl@0	2459	** the name of a master journal file that should be written into the
sl@0	2460	** individual journal file, or is NULL, indicating no master journal file
sl@0	2461	** (single database transaction).
sl@0	2462	**
sl@0	2463	** When this is called, the master journal should already have been
sl@0	2464	** created, populated with this journal pointer and synced to disk.
sl@0	2465	**
sl@0	2466	** Once this is routine has returned, the only thing required to commit
sl@0	2467	** the write-transaction for this database file is to delete the journal.
sl@0	2468	*/
sl@0	2469	int sqlite3BtreeCommitPhaseOne(Btree p, const char zMaster){
sl@0	2470	int rc = SQLITE_OK;
sl@0	2471	if( p->inTrans==TRANS_WRITE ){
sl@0	2472	BtShared *pBt = p->pBt;
sl@0	2473	Pgno nTrunc = 0;
sl@0	2474	sqlite3BtreeEnter(p);
sl@0	2475	pBt->db = p->db;
sl@0	2476	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	2477	if( pBt->autoVacuum ){
sl@0	2478	rc = autoVacuumCommit(pBt, &nTrunc);
sl@0	2479	if( rc!=SQLITE_OK ){
sl@0	2480	sqlite3BtreeLeave(p);
sl@0	2481	return rc;
sl@0	2482	}
sl@0	2483	}
sl@0	2484	#endif
sl@0	2485	rc = sqlite3PagerCommitPhaseOne(pBt->pPager, zMaster, nTrunc, 0);
sl@0	2486	sqlite3BtreeLeave(p);
sl@0	2487	}
sl@0	2488	return rc;
sl@0	2489	}
sl@0	2490
sl@0	2491	/*
sl@0	2492	** Commit the transaction currently in progress.
sl@0	2493	**
sl@0	2494	** This routine implements the second phase of a 2-phase commit. The
sl@0	2495	** sqlite3BtreeSync() routine does the first phase and should be invoked
sl@0	2496	** prior to calling this routine. The sqlite3BtreeSync() routine did
sl@0	2497	** all the work of writing information out to disk and flushing the
sl@0	2498	** contents so that they are written onto the disk platter. All this
sl@0	2499	** routine has to do is delete or truncate the rollback journal
sl@0	2500	** (which causes the transaction to commit) and drop locks.
sl@0	2501	**
sl@0	2502	** This will release the write lock on the database file. If there
sl@0	2503	** are no active cursors, it also releases the read lock.
sl@0	2504	*/
sl@0	2505	int sqlite3BtreeCommitPhaseTwo(Btree *p){
sl@0	2506	BtShared *pBt = p->pBt;
sl@0	2507
sl@0	2508	sqlite3BtreeEnter(p);
sl@0	2509	pBt->db = p->db;
sl@0	2510	btreeIntegrity(p);
sl@0	2511
sl@0	2512	/* If the handle has a write-transaction open, commit the shared-btrees
sl@0	2513	** transaction and set the shared state to TRANS_READ.
sl@0	2514	*/
sl@0	2515	if( p->inTrans==TRANS_WRITE ){
sl@0	2516	int rc;
sl@0	2517	assert( pBt->inTransaction==TRANS_WRITE );
sl@0	2518	assert( pBt->nTransaction>0 );
sl@0	2519	rc = sqlite3PagerCommitPhaseTwo(pBt->pPager);
sl@0	2520	if( rc!=SQLITE_OK ){
sl@0	2521	sqlite3BtreeLeave(p);
sl@0	2522	return rc;
sl@0	2523	}
sl@0	2524	pBt->inTransaction = TRANS_READ;
sl@0	2525	pBt->inStmt = 0;
sl@0	2526	}
sl@0	2527	unlockAllTables(p);
sl@0	2528
sl@0	2529	/* If the handle has any kind of transaction open, decrement the transaction
sl@0	2530	** count of the shared btree. If the transaction count reaches 0, set
sl@0	2531	** the shared state to TRANS_NONE. The unlockBtreeIfUnused() call below
sl@0	2532	** will unlock the pager.
sl@0	2533	*/
sl@0	2534	if( p->inTrans!=TRANS_NONE ){
sl@0	2535	pBt->nTransaction--;
sl@0	2536	if( 0==pBt->nTransaction ){
sl@0	2537	pBt->inTransaction = TRANS_NONE;
sl@0	2538	}
sl@0	2539	}
sl@0	2540
sl@0	2541	/* Set the handles current transaction state to TRANS_NONE and unlock
sl@0	2542	** the pager if this call closed the only read or write transaction.
sl@0	2543	*/
sl@0	2544	p->inTrans = TRANS_NONE;
sl@0	2545	unlockBtreeIfUnused(pBt);
sl@0	2546
sl@0	2547	btreeIntegrity(p);
sl@0	2548	sqlite3BtreeLeave(p);
sl@0	2549	return SQLITE_OK;
sl@0	2550	}
sl@0	2551
sl@0	2552	/*
sl@0	2553	** Do both phases of a commit.
sl@0	2554	*/
sl@0	2555	int sqlite3BtreeCommit(Btree *p){
sl@0	2556	int rc;
sl@0	2557	sqlite3BtreeEnter(p);
sl@0	2558	rc = sqlite3BtreeCommitPhaseOne(p, 0);
sl@0	2559	if( rc==SQLITE_OK ){
sl@0	2560	rc = sqlite3BtreeCommitPhaseTwo(p);
sl@0	2561	}
sl@0	2562	sqlite3BtreeLeave(p);
sl@0	2563	return rc;
sl@0	2564	}
sl@0	2565
sl@0	2566	#ifndef NDEBUG
sl@0	2567	/*
sl@0	2568	** Return the number of write-cursors open on this handle. This is for use
sl@0	2569	** in assert() expressions, so it is only compiled if NDEBUG is not
sl@0	2570	** defined.
sl@0	2571	**
sl@0	2572	** For the purposes of this routine, a write-cursor is any cursor that
sl@0	2573	** is capable of writing to the databse. That means the cursor was
sl@0	2574	** originally opened for writing and the cursor has not be disabled
sl@0	2575	** by having its state changed to CURSOR_FAULT.
sl@0	2576	*/
sl@0	2577	static int countWriteCursors(BtShared *pBt){
sl@0	2578	BtCursor *pCur;
sl@0	2579	int r = 0;
sl@0	2580	for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
sl@0	2581	if( pCur->wrFlag && pCur->eState!=CURSOR_FAULT ) r++;
sl@0	2582	}
sl@0	2583	return r;
sl@0	2584	}
sl@0	2585	#endif
sl@0	2586
sl@0	2587	/*
sl@0	2588	** This routine sets the state to CURSOR_FAULT and the error
sl@0	2589	** code to errCode for every cursor on BtShared that pBtree
sl@0	2590	** references.
sl@0	2591	**
sl@0	2592	** Every cursor is tripped, including cursors that belong
sl@0	2593	** to other database connections that happen to be sharing
sl@0	2594	** the cache with pBtree.
sl@0	2595	**
sl@0	2596	** This routine gets called when a rollback occurs.
sl@0	2597	** All cursors using the same cache must be tripped
sl@0	2598	** to prevent them from trying to use the btree after
sl@0	2599	** the rollback. The rollback may have deleted tables
sl@0	2600	** or moved root pages, so it is not sufficient to
sl@0	2601	** save the state of the cursor. The cursor must be
sl@0	2602	** invalidated.
sl@0	2603	*/
sl@0	2604	void sqlite3BtreeTripAllCursors(Btree *pBtree, int errCode){
sl@0	2605	BtCursor *p;
sl@0	2606	sqlite3BtreeEnter(pBtree);
sl@0	2607	for(p=pBtree->pBt->pCursor; p; p=p->pNext){
sl@0	2608	sqlite3BtreeClearCursor(p);
sl@0	2609	p->eState = CURSOR_FAULT;
sl@0	2610	p->skip = errCode;
sl@0	2611	}
sl@0	2612	sqlite3BtreeLeave(pBtree);
sl@0	2613	}
sl@0	2614
sl@0	2615	/*
sl@0	2616	** Rollback the transaction in progress. All cursors will be
sl@0	2617	** invalided by this operation. Any attempt to use a cursor
sl@0	2618	** that was open at the beginning of this operation will result
sl@0	2619	** in an error.
sl@0	2620	**
sl@0	2621	** This will release the write lock on the database file. If there
sl@0	2622	** are no active cursors, it also releases the read lock.
sl@0	2623	*/
sl@0	2624	int sqlite3BtreeRollback(Btree *p){
sl@0	2625	int rc;
sl@0	2626	BtShared *pBt = p->pBt;
sl@0	2627	MemPage *pPage1;
sl@0	2628
sl@0	2629	sqlite3BtreeEnter(p);
sl@0	2630	pBt->db = p->db;
sl@0	2631	rc = saveAllCursors(pBt, 0, 0);
sl@0	2632	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	2633	if( rc!=SQLITE_OK ){
sl@0	2634	/* This is a horrible situation. An IO or malloc() error occured whilst
sl@0	2635	** trying to save cursor positions. If this is an automatic rollback (as
sl@0	2636	** the result of a constraint, malloc() failure or IO error) then
sl@0	2637	** the cache may be internally inconsistent (not contain valid trees) so
sl@0	2638	** we cannot simply return the error to the caller. Instead, abort
sl@0	2639	** all queries that may be using any of the cursors that failed to save.
sl@0	2640	*/
sl@0	2641	sqlite3BtreeTripAllCursors(p, rc);
sl@0	2642	}
sl@0	2643	#endif
sl@0	2644	btreeIntegrity(p);
sl@0	2645	unlockAllTables(p);
sl@0	2646
sl@0	2647	if( p->inTrans==TRANS_WRITE ){
sl@0	2648	int rc2;
sl@0	2649
sl@0	2650	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	2651	pBt->nTrunc = 0;
sl@0	2652	#endif
sl@0	2653
sl@0	2654	assert( TRANS_WRITE==pBt->inTransaction );
sl@0	2655	rc2 = sqlite3PagerRollback(pBt->pPager);
sl@0	2656	if( rc2!=SQLITE_OK ){
sl@0	2657	rc = rc2;
sl@0	2658	}
sl@0	2659
sl@0	2660	/* The rollback may have destroyed the pPage1->aData value. So
sl@0	2661	** call sqlite3BtreeGetPage() on page 1 again to make
sl@0	2662	** sure pPage1->aData is set correctly. */
sl@0	2663	if( sqlite3BtreeGetPage(pBt, 1, &pPage1, 0)==SQLITE_OK ){
sl@0	2664	releasePage(pPage1);
sl@0	2665	}
sl@0	2666	assert( countWriteCursors(pBt)==0 );
sl@0	2667	pBt->inTransaction = TRANS_READ;
sl@0	2668	}
sl@0	2669
sl@0	2670	if( p->inTrans!=TRANS_NONE ){
sl@0	2671	assert( pBt->nTransaction>0 );
sl@0	2672	pBt->nTransaction--;
sl@0	2673	if( 0==pBt->nTransaction ){
sl@0	2674	pBt->inTransaction = TRANS_NONE;
sl@0	2675	}
sl@0	2676	}
sl@0	2677
sl@0	2678	p->inTrans = TRANS_NONE;
sl@0	2679	pBt->inStmt = 0;
sl@0	2680	unlockBtreeIfUnused(pBt);
sl@0	2681
sl@0	2682	btreeIntegrity(p);
sl@0	2683	sqlite3BtreeLeave(p);
sl@0	2684	return rc;
sl@0	2685	}
sl@0	2686
sl@0	2687	/*
sl@0	2688	** Start a statement subtransaction. The subtransaction can
sl@0	2689	** can be rolled back independently of the main transaction.
sl@0	2690	** You must start a transaction before starting a subtransaction.
sl@0	2691	** The subtransaction is ended automatically if the main transaction
sl@0	2692	** commits or rolls back.
sl@0	2693	**
sl@0	2694	** Only one subtransaction may be active at a time. It is an error to try
sl@0	2695	** to start a new subtransaction if another subtransaction is already active.
sl@0	2696	**
sl@0	2697	** Statement subtransactions are used around individual SQL statements
sl@0	2698	** that are contained within a BEGIN...COMMIT block. If a constraint
sl@0	2699	** error occurs within the statement, the effect of that one statement
sl@0	2700	** can be rolled back without having to rollback the entire transaction.
sl@0	2701	*/
sl@0	2702	int sqlite3BtreeBeginStmt(Btree *p){
sl@0	2703	int rc;
sl@0	2704	BtShared *pBt = p->pBt;
sl@0	2705	sqlite3BtreeEnter(p);
sl@0	2706	pBt->db = p->db;
sl@0	2707	if( (p->inTrans!=TRANS_WRITE) \|\| pBt->inStmt ){
sl@0	2708	rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	2709	}else{
sl@0	2710	assert( pBt->inTransaction==TRANS_WRITE );
sl@0	2711	rc = pBt->readOnly ? SQLITE_OK : sqlite3PagerStmtBegin(pBt->pPager);
sl@0	2712	pBt->inStmt = 1;
sl@0	2713	}
sl@0	2714	sqlite3BtreeLeave(p);
sl@0	2715	return rc;
sl@0	2716	}
sl@0	2717
sl@0	2718
sl@0	2719	/*
sl@0	2720	** Commit the statment subtransaction currently in progress. If no
sl@0	2721	** subtransaction is active, this is a no-op.
sl@0	2722	*/
sl@0	2723	int sqlite3BtreeCommitStmt(Btree *p){
sl@0	2724	int rc;
sl@0	2725	BtShared *pBt = p->pBt;
sl@0	2726	sqlite3BtreeEnter(p);
sl@0	2727	pBt->db = p->db;
sl@0	2728	if( pBt->inStmt && !pBt->readOnly ){
sl@0	2729	rc = sqlite3PagerStmtCommit(pBt->pPager);
sl@0	2730	}else{
sl@0	2731	rc = SQLITE_OK;
sl@0	2732	}
sl@0	2733	pBt->inStmt = 0;
sl@0	2734	sqlite3BtreeLeave(p);
sl@0	2735	return rc;
sl@0	2736	}
sl@0	2737
sl@0	2738	/*
sl@0	2739	** Rollback the active statement subtransaction. If no subtransaction
sl@0	2740	** is active this routine is a no-op.
sl@0	2741	**
sl@0	2742	** All cursors will be invalidated by this operation. Any attempt
sl@0	2743	** to use a cursor that was open at the beginning of this operation
sl@0	2744	** will result in an error.
sl@0	2745	*/
sl@0	2746	int sqlite3BtreeRollbackStmt(Btree *p){
sl@0	2747	int rc = SQLITE_OK;
sl@0	2748	BtShared *pBt = p->pBt;
sl@0	2749	sqlite3BtreeEnter(p);
sl@0	2750	pBt->db = p->db;
sl@0	2751	if( pBt->inStmt && !pBt->readOnly ){
sl@0	2752	rc = sqlite3PagerStmtRollback(pBt->pPager);
sl@0	2753	pBt->inStmt = 0;
sl@0	2754	}
sl@0	2755	sqlite3BtreeLeave(p);
sl@0	2756	return rc;
sl@0	2757	}
sl@0	2758
sl@0	2759	/*
sl@0	2760	** Create a new cursor for the BTree whose root is on the page
sl@0	2761	** iTable. The act of acquiring a cursor gets a read lock on
sl@0	2762	** the database file.
sl@0	2763	**
sl@0	2764	** If wrFlag==0, then the cursor can only be used for reading.
sl@0	2765	** If wrFlag==1, then the cursor can be used for reading or for
sl@0	2766	** writing if other conditions for writing are also met. These
sl@0	2767	** are the conditions that must be met in order for writing to
sl@0	2768	** be allowed:
sl@0	2769	**
sl@0	2770	** 1: The cursor must have been opened with wrFlag==1
sl@0	2771	**
sl@0	2772	** 2: Other database connections that share the same pager cache
sl@0	2773	** but which are not in the READ_UNCOMMITTED state may not have
sl@0	2774	** cursors open with wrFlag==0 on the same table. Otherwise
sl@0	2775	** the changes made by this write cursor would be visible to
sl@0	2776	** the read cursors in the other database connection.
sl@0	2777	**
sl@0	2778	** 3: The database must be writable (not on read-only media)
sl@0	2779	**
sl@0	2780	** 4: There must be an active transaction.
sl@0	2781	**
sl@0	2782	** No checking is done to make sure that page iTable really is the
sl@0	2783	** root page of a b-tree. If it is not, then the cursor acquired
sl@0	2784	** will not work correctly.
sl@0	2785	**
sl@0	2786	** It is assumed that the sqlite3BtreeCursorSize() bytes of memory
sl@0	2787	** pointed to by pCur have been zeroed by the caller.
sl@0	2788	*/
sl@0	2789	static int btreeCursor(
sl@0	2790	Btree p, / The btree */
sl@0	2791	int iTable, /* Root page of table to open */
sl@0	2792	int wrFlag, /* 1 to write. 0 read-only */
sl@0	2793	struct KeyInfo pKeyInfo, / First arg to comparison function */
sl@0	2794	BtCursor pCur / Space for new cursor */
sl@0	2795	){
sl@0	2796	int rc;
sl@0	2797	BtShared *pBt = p->pBt;
sl@0	2798
sl@0	2799	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	2800	if( wrFlag ){
sl@0	2801	if( pBt->readOnly ){
sl@0	2802	return SQLITE_READONLY;
sl@0	2803	}
sl@0	2804	if( checkReadLocks(p, iTable, 0, 0) ){
sl@0	2805	return SQLITE_LOCKED;
sl@0	2806	}
sl@0	2807	}
sl@0	2808
sl@0	2809	if( pBt->pPage1==0 ){
sl@0	2810	rc = lockBtreeWithRetry(p);
sl@0	2811	if( rc!=SQLITE_OK ){
sl@0	2812	return rc;
sl@0	2813	}
sl@0	2814	if( pBt->readOnly && wrFlag ){
sl@0	2815	return SQLITE_READONLY;
sl@0	2816	}
sl@0	2817	}
sl@0	2818	pCur->pgnoRoot = (Pgno)iTable;
sl@0	2819	if( iTable==1 && pagerPagecount(pBt->pPager)==0 ){
sl@0	2820	rc = SQLITE_EMPTY;
sl@0	2821	goto create_cursor_exception;
sl@0	2822	}
sl@0	2823	rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]);
sl@0	2824	if( rc!=SQLITE_OK ){
sl@0	2825	goto create_cursor_exception;
sl@0	2826	}
sl@0	2827
sl@0	2828	/* Now that no other errors can occur, finish filling in the BtCursor
sl@0	2829	** variables, link the cursor into the BtShared list and set *ppCur (the
sl@0	2830	** output argument to this function).
sl@0	2831	*/
sl@0	2832	pCur->pKeyInfo = pKeyInfo;
sl@0	2833	pCur->pBtree = p;
sl@0	2834	pCur->pBt = pBt;
sl@0	2835	pCur->wrFlag = wrFlag;
sl@0	2836	pCur->pNext = pBt->pCursor;
sl@0	2837	if( pCur->pNext ){
sl@0	2838	pCur->pNext->pPrev = pCur;
sl@0	2839	}
sl@0	2840	pBt->pCursor = pCur;
sl@0	2841	pCur->eState = CURSOR_INVALID;
sl@0	2842
sl@0	2843	return SQLITE_OK;
sl@0	2844
sl@0	2845	create_cursor_exception:
sl@0	2846	releasePage(pCur->apPage[0]);
sl@0	2847	unlockBtreeIfUnused(pBt);
sl@0	2848	return rc;
sl@0	2849	}
sl@0	2850	int sqlite3BtreeCursor(
sl@0	2851	Btree p, / The btree */
sl@0	2852	int iTable, /* Root page of table to open */
sl@0	2853	int wrFlag, /* 1 to write. 0 read-only */
sl@0	2854	struct KeyInfo pKeyInfo, / First arg to xCompare() */
sl@0	2855	BtCursor pCur / Write new cursor here */
sl@0	2856	){
sl@0	2857	int rc;
sl@0	2858	sqlite3BtreeEnter(p);
sl@0	2859	p->pBt->db = p->db;
sl@0	2860	rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
sl@0	2861	sqlite3BtreeLeave(p);
sl@0	2862	return rc;
sl@0	2863	}
sl@0	2864	int sqlite3BtreeCursorSize(){
sl@0	2865	return sizeof(BtCursor);
sl@0	2866	}
sl@0	2867
sl@0	2868
sl@0	2869
sl@0	2870	/*
sl@0	2871	** Close a cursor. The read lock on the database file is released
sl@0	2872	** when the last cursor is closed.
sl@0	2873	*/
sl@0	2874	int sqlite3BtreeCloseCursor(BtCursor *pCur){
sl@0	2875	Btree *pBtree = pCur->pBtree;
sl@0	2876	if( pBtree ){
sl@0	2877	int i;
sl@0	2878	BtShared *pBt = pCur->pBt;
sl@0	2879	sqlite3BtreeEnter(pBtree);
sl@0	2880	pBt->db = pBtree->db;
sl@0	2881	sqlite3BtreeClearCursor(pCur);
sl@0	2882	if( pCur->pPrev ){
sl@0	2883	pCur->pPrev->pNext = pCur->pNext;
sl@0	2884	}else{
sl@0	2885	pBt->pCursor = pCur->pNext;
sl@0	2886	}
sl@0	2887	if( pCur->pNext ){
sl@0	2888	pCur->pNext->pPrev = pCur->pPrev;
sl@0	2889	}
sl@0	2890	for(i=0; i<=pCur->iPage; i++){
sl@0	2891	releasePage(pCur->apPage[i]);
sl@0	2892	}
sl@0	2893	unlockBtreeIfUnused(pBt);
sl@0	2894	invalidateOverflowCache(pCur);
sl@0	2895	/* sqlite3_free(pCur); */
sl@0	2896	sqlite3BtreeLeave(pBtree);
sl@0	2897	}
sl@0	2898	return SQLITE_OK;
sl@0	2899	}
sl@0	2900
sl@0	2901	/*
sl@0	2902	** Make a temporary cursor by filling in the fields of pTempCur.
sl@0	2903	** The temporary cursor is not on the cursor list for the Btree.
sl@0	2904	*/
sl@0	2905	void sqlite3BtreeGetTempCursor(BtCursor pCur, BtCursor pTempCur){
sl@0	2906	int i;
sl@0	2907	assert( cursorHoldsMutex(pCur) );
sl@0	2908	memcpy(pTempCur, pCur, sizeof(BtCursor));
sl@0	2909	pTempCur->pNext = 0;
sl@0	2910	pTempCur->pPrev = 0;
sl@0	2911	for(i=0; i<=pTempCur->iPage; i++){
sl@0	2912	sqlite3PagerRef(pTempCur->apPage[i]->pDbPage);
sl@0	2913	}
sl@0	2914	}
sl@0	2915
sl@0	2916	/*
sl@0	2917	** Delete a temporary cursor such as was made by the CreateTemporaryCursor()
sl@0	2918	** function above.
sl@0	2919	*/
sl@0	2920	void sqlite3BtreeReleaseTempCursor(BtCursor *pCur){
sl@0	2921	int i;
sl@0	2922	assert( cursorHoldsMutex(pCur) );
sl@0	2923	for(i=0; i<=pCur->iPage; i++){
sl@0	2924	sqlite3PagerUnref(pCur->apPage[i]->pDbPage);
sl@0	2925	}
sl@0	2926	}
sl@0	2927
sl@0	2928	/*
sl@0	2929	** Make sure the BtCursor* given in the argument has a valid
sl@0	2930	** BtCursor.info structure. If it is not already valid, call
sl@0	2931	** sqlite3BtreeParseCell() to fill it in.
sl@0	2932	**
sl@0	2933	** BtCursor.info is a cache of the information in the current cell.
sl@0	2934	** Using this cache reduces the number of calls to sqlite3BtreeParseCell().
sl@0	2935	**
sl@0	2936	** 2007-06-25: There is a bug in some versions of MSVC that cause the
sl@0	2937	** compiler to crash when getCellInfo() is implemented as a macro.
sl@0	2938	** But there is a measureable speed advantage to using the macro on gcc
sl@0	2939	** (when less compiler optimizations like -Os or -O0 are used and the
sl@0	2940	** compiler is not doing agressive inlining.) So we use a real function
sl@0	2941	** for MSVC and a macro for everything else. Ticket #2457.
sl@0	2942	*/
sl@0	2943	#ifndef NDEBUG
sl@0	2944	static void assertCellInfo(BtCursor *pCur){
sl@0	2945	CellInfo info;
sl@0	2946	int iPage = pCur->iPage;
sl@0	2947	memset(&info, 0, sizeof(info));
sl@0	2948	sqlite3BtreeParseCell(pCur->apPage[iPage], pCur->aiIdx[iPage], &info);
sl@0	2949	assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
sl@0	2950	}
sl@0	2951	#else
sl@0	2952	#define assertCellInfo(x)
sl@0	2953	#endif
sl@0	2954	#ifdef _MSC_VER
sl@0	2955	/* Use a real function in MSVC to work around bugs in that compiler. */
sl@0	2956	static void getCellInfo(BtCursor *pCur){
sl@0	2957	if( pCur->info.nSize==0 ){
sl@0	2958	int iPage = pCur->iPage;
sl@0	2959	sqlite3BtreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info);
sl@0	2960	pCur->validNKey = 1;
sl@0	2961	}else{
sl@0	2962	assertCellInfo(pCur);
sl@0	2963	}
sl@0	2964	}
sl@0	2965	#else /* if not _MSC_VER */
sl@0	2966	/* Use a macro in all other compilers so that the function is inlined */
sl@0	2967	#define getCellInfo(pCur) \
sl@0	2968	if( pCur->info.nSize==0 ){ \
sl@0	2969	int iPage = pCur->iPage; \
sl@0	2970	sqlite3BtreeParseCell(pCur->apPage[iPage],pCur->aiIdx[iPage],&pCur->info); \
sl@0	2971	pCur->validNKey = 1; \
sl@0	2972	}else{ \
sl@0	2973	assertCellInfo(pCur); \
sl@0	2974	}
sl@0	2975	#endif /* _MSC_VER */
sl@0	2976
sl@0	2977	/*
sl@0	2978	** Set *pSize to the size of the buffer needed to hold the value of
sl@0	2979	** the key for the current entry. If the cursor is not pointing
sl@0	2980	** to a valid entry, *pSize is set to 0.
sl@0	2981	**
sl@0	2982	** For a table with the INTKEY flag set, this routine returns the key
sl@0	2983	** itself, not the number of bytes in the key.
sl@0	2984	*/
sl@0	2985	int sqlite3BtreeKeySize(BtCursor pCur, i64 pSize){
sl@0	2986	int rc;
sl@0	2987
sl@0	2988	assert( cursorHoldsMutex(pCur) );
sl@0	2989	rc = restoreCursorPosition(pCur);
sl@0	2990	if( rc==SQLITE_OK ){
sl@0	2991	assert( pCur->eState==CURSOR_INVALID \|\| pCur->eState==CURSOR_VALID );
sl@0	2992	if( pCur->eState==CURSOR_INVALID ){
sl@0	2993	*pSize = 0;
sl@0	2994	}else{
sl@0	2995	getCellInfo(pCur);
sl@0	2996	*pSize = pCur->info.nKey;
sl@0	2997	}
sl@0	2998	}
sl@0	2999	return rc;
sl@0	3000	}
sl@0	3001
sl@0	3002	/*
sl@0	3003	** Set *pSize to the number of bytes of data in the entry the
sl@0	3004	** cursor currently points to. Always return SQLITE_OK.
sl@0	3005	** Failure is not possible. If the cursor is not currently
sl@0	3006	** pointing to an entry (which can happen, for example, if
sl@0	3007	** the database is empty) then *pSize is set to 0.
sl@0	3008	*/
sl@0	3009	int sqlite3BtreeDataSize(BtCursor pCur, u32 pSize){
sl@0	3010	int rc;
sl@0	3011
sl@0	3012	assert( cursorHoldsMutex(pCur) );
sl@0	3013	rc = restoreCursorPosition(pCur);
sl@0	3014	if( rc==SQLITE_OK ){
sl@0	3015	assert( pCur->eState==CURSOR_INVALID \|\| pCur->eState==CURSOR_VALID );
sl@0	3016	if( pCur->eState==CURSOR_INVALID ){
sl@0	3017	/* Not pointing at a valid entry - set pSize to 0. /
sl@0	3018	*pSize = 0;
sl@0	3019	}else{
sl@0	3020	getCellInfo(pCur);
sl@0	3021	*pSize = pCur->info.nData;
sl@0	3022	}
sl@0	3023	}
sl@0	3024	return rc;
sl@0	3025	}
sl@0	3026
sl@0	3027	/*
sl@0	3028	** Given the page number of an overflow page in the database (parameter
sl@0	3029	** ovfl), this function finds the page number of the next page in the
sl@0	3030	** linked list of overflow pages. If possible, it uses the auto-vacuum
sl@0	3031	** pointer-map data instead of reading the content of page ovfl to do so.
sl@0	3032	**
sl@0	3033	** If an error occurs an SQLite error code is returned. Otherwise:
sl@0	3034	**
sl@0	3035	** Unless pPgnoNext is NULL, the page number of the next overflow
sl@0	3036	** page in the linked list is written to *pPgnoNext. If page ovfl
sl@0	3037	** is the last page in its linked list, *pPgnoNext is set to zero.
sl@0	3038	**
sl@0	3039	** If ppPage is not NULL, ppPage is set to the MemPage handle
sl@0	3040	** for page ovfl. The underlying pager page may have been requested
sl@0	3041	** with the noContent flag set, so the page data accessable via
sl@0	3042	** this handle may not be trusted.
sl@0	3043	*/
sl@0	3044	static int getOverflowPage(
sl@0	3045	BtShared *pBt,
sl@0	3046	Pgno ovfl, /* Overflow page */
sl@0	3047	MemPage *ppPage, / OUT: MemPage handle */
sl@0	3048	Pgno pPgnoNext / OUT: Next overflow page number */
sl@0	3049	){
sl@0	3050	Pgno next = 0;
sl@0	3051	int rc;
sl@0	3052
sl@0	3053	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	3054	/* One of these must not be NULL. Otherwise, why call this function? */
sl@0	3055	assert(ppPage \|\| pPgnoNext);
sl@0	3056
sl@0	3057	/* If pPgnoNext is NULL, then this function is being called to obtain
sl@0	3058	** a MemPage* reference only. No page-data is required in this case.
sl@0	3059	*/
sl@0	3060	if( !pPgnoNext ){
sl@0	3061	return sqlite3BtreeGetPage(pBt, ovfl, ppPage, 1);
sl@0	3062	}
sl@0	3063
sl@0	3064	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	3065	/* Try to find the next page in the overflow list using the
sl@0	3066	** autovacuum pointer-map pages. Guess that the next page in
sl@0	3067	** the overflow list is page number (ovfl+1). If that guess turns
sl@0	3068	** out to be wrong, fall back to loading the data of page
sl@0	3069	** number ovfl to determine the next page number.
sl@0	3070	*/
sl@0	3071	if( pBt->autoVacuum ){
sl@0	3072	Pgno pgno;
sl@0	3073	Pgno iGuess = ovfl+1;
sl@0	3074	u8 eType;
sl@0	3075
sl@0	3076	while( PTRMAP_ISPAGE(pBt, iGuess) \|\| iGuess==PENDING_BYTE_PAGE(pBt) ){
sl@0	3077	iGuess++;
sl@0	3078	}
sl@0	3079
sl@0	3080	if( iGuess<=pagerPagecount(pBt->pPager) ){
sl@0	3081	rc = ptrmapGet(pBt, iGuess, &eType, &pgno);
sl@0	3082	if( rc!=SQLITE_OK ){
sl@0	3083	return rc;
sl@0	3084	}
sl@0	3085	if( eType==PTRMAP_OVERFLOW2 && pgno==ovfl ){
sl@0	3086	next = iGuess;
sl@0	3087	}
sl@0	3088	}
sl@0	3089	}
sl@0	3090	#endif
sl@0	3091
sl@0	3092	if( next==0 \|\| ppPage ){
sl@0	3093	MemPage *pPage = 0;
sl@0	3094
sl@0	3095	rc = sqlite3BtreeGetPage(pBt, ovfl, &pPage, next!=0);
sl@0	3096	assert(rc==SQLITE_OK \|\| pPage==0);
sl@0	3097	if( next==0 && rc==SQLITE_OK ){
sl@0	3098	next = get4byte(pPage->aData);
sl@0	3099	}
sl@0	3100
sl@0	3101	if( ppPage ){
sl@0	3102	*ppPage = pPage;
sl@0	3103	}else{
sl@0	3104	releasePage(pPage);
sl@0	3105	}
sl@0	3106	}
sl@0	3107	*pPgnoNext = next;
sl@0	3108
sl@0	3109	return rc;
sl@0	3110	}
sl@0	3111
sl@0	3112	/*
sl@0	3113	** Copy data from a buffer to a page, or from a page to a buffer.
sl@0	3114	**
sl@0	3115	** pPayload is a pointer to data stored on database page pDbPage.
sl@0	3116	** If argument eOp is false, then nByte bytes of data are copied
sl@0	3117	** from pPayload to the buffer pointed at by pBuf. If eOp is true,
sl@0	3118	** then sqlite3PagerWrite() is called on pDbPage and nByte bytes
sl@0	3119	** of data are copied from the buffer pBuf to pPayload.
sl@0	3120	**
sl@0	3121	** SQLITE_OK is returned on success, otherwise an error code.
sl@0	3122	*/
sl@0	3123	static int copyPayload(
sl@0	3124	void pPayload, / Pointer to page data */
sl@0	3125	void pBuf, / Pointer to buffer */
sl@0	3126	int nByte, /* Number of bytes to copy */
sl@0	3127	int eOp, /* 0 -> copy from page, 1 -> copy to page */
sl@0	3128	DbPage pDbPage / Page containing pPayload */
sl@0	3129	){
sl@0	3130	if( eOp ){
sl@0	3131	/* Copy data from buffer to page (a write operation) */
sl@0	3132	int rc = sqlite3PagerWrite(pDbPage);
sl@0	3133	if( rc!=SQLITE_OK ){
sl@0	3134	return rc;
sl@0	3135	}
sl@0	3136	memcpy(pPayload, pBuf, nByte);
sl@0	3137	}else{
sl@0	3138	/* Copy data from page to buffer (a read operation) */
sl@0	3139	memcpy(pBuf, pPayload, nByte);
sl@0	3140	}
sl@0	3141	return SQLITE_OK;
sl@0	3142	}
sl@0	3143
sl@0	3144	/*
sl@0	3145	** This function is used to read or overwrite payload information
sl@0	3146	** for the entry that the pCur cursor is pointing to. If the eOp
sl@0	3147	** parameter is 0, this is a read operation (data copied into
sl@0	3148	** buffer pBuf). If it is non-zero, a write (data copied from
sl@0	3149	** buffer pBuf).
sl@0	3150	**
sl@0	3151	** A total of "amt" bytes are read or written beginning at "offset".
sl@0	3152	** Data is read to or from the buffer pBuf.
sl@0	3153	**
sl@0	3154	** This routine does not make a distinction between key and data.
sl@0	3155	** It just reads or writes bytes from the payload area. Data might
sl@0	3156	** appear on the main page or be scattered out on multiple overflow
sl@0	3157	** pages.
sl@0	3158	**
sl@0	3159	** If the BtCursor.isIncrblobHandle flag is set, and the current
sl@0	3160	** cursor entry uses one or more overflow pages, this function
sl@0	3161	** allocates space for and lazily popluates the overflow page-list
sl@0	3162	** cache array (BtCursor.aOverflow). Subsequent calls use this
sl@0	3163	** cache to make seeking to the supplied offset more efficient.
sl@0	3164	**
sl@0	3165	** Once an overflow page-list cache has been allocated, it may be
sl@0	3166	** invalidated if some other cursor writes to the same table, or if
sl@0	3167	** the cursor is moved to a different row. Additionally, in auto-vacuum
sl@0	3168	** mode, the following events may invalidate an overflow page-list cache.
sl@0	3169	**
sl@0	3170	** * An incremental vacuum,
sl@0	3171	** * A commit in auto_vacuum="full" mode,
sl@0	3172	** * Creating a table (may require moving an overflow page).
sl@0	3173	*/
sl@0	3174	static int accessPayload(
sl@0	3175	BtCursor pCur, / Cursor pointing to entry to read from */
sl@0	3176	int offset, /* Begin reading this far into payload */
sl@0	3177	int amt, /* Read this many bytes */
sl@0	3178	unsigned char pBuf, / Write the bytes into this buffer */
sl@0	3179	int skipKey, /* offset begins at data if this is true */
sl@0	3180	int eOp /* zero to read. non-zero to write. */
sl@0	3181	){
sl@0	3182	unsigned char *aPayload;
sl@0	3183	int rc = SQLITE_OK;
sl@0	3184	u32 nKey;
sl@0	3185	int iIdx = 0;
sl@0	3186	MemPage pPage = pCur->apPage[pCur->iPage]; / Btree page of current entry */
sl@0	3187	BtShared pBt = pCur->pBt; / Btree this cursor belongs to */
sl@0	3188
sl@0	3189	assert( pPage );
sl@0	3190	assert( pCur->eState==CURSOR_VALID );
sl@0	3191	assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
sl@0	3192	assert( offset>=0 );
sl@0	3193	assert( cursorHoldsMutex(pCur) );
sl@0	3194
sl@0	3195	getCellInfo(pCur);
sl@0	3196	aPayload = pCur->info.pCell + pCur->info.nHeader;
sl@0	3197	nKey = (pPage->intKey ? 0 : pCur->info.nKey);
sl@0	3198
sl@0	3199	if( skipKey ){
sl@0	3200	offset += nKey;
sl@0	3201	}
sl@0	3202	if( offset+amt > nKey+pCur->info.nData
sl@0	3203	\|\| &aPayload[pCur->info.nLocal] > &pPage->aData[pBt->usableSize]
sl@0	3204	){
sl@0	3205	/* Trying to read or write past the end of the data is an error */
sl@0	3206	return SQLITE_CORRUPT_BKPT;
sl@0	3207	}
sl@0	3208
sl@0	3209	/* Check if data must be read/written to/from the btree page itself. */
sl@0	3210	if( offset<pCur->info.nLocal ){
sl@0	3211	int a = amt;
sl@0	3212	if( a+offset>pCur->info.nLocal ){
sl@0	3213	a = pCur->info.nLocal - offset;
sl@0	3214	}
sl@0	3215	rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
sl@0	3216	offset = 0;
sl@0	3217	pBuf += a;
sl@0	3218	amt -= a;
sl@0	3219	}else{
sl@0	3220	offset -= pCur->info.nLocal;
sl@0	3221	}
sl@0	3222
sl@0	3223	pBt = pCur->pBt;
sl@0	3224	if( rc==SQLITE_OK && amt>0 ){
sl@0	3225	const int ovflSize = pBt->usableSize - 4; /* Bytes content per ovfl page */
sl@0	3226	Pgno nextPage;
sl@0	3227
sl@0	3228	nextPage = get4byte(&aPayload[pCur->info.nLocal]);
sl@0	3229
sl@0	3230	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	3231	/* If the isIncrblobHandle flag is set and the BtCursor.aOverflow[]
sl@0	3232	** has not been allocated, allocate it now. The array is sized at
sl@0	3233	** one entry for each overflow page in the overflow chain. The
sl@0	3234	** page number of the first overflow page is stored in aOverflow[0],
sl@0	3235	** etc. A value of 0 in the aOverflow[] array means "not yet known"
sl@0	3236	** (the cache is lazily populated).
sl@0	3237	*/
sl@0	3238	if( pCur->isIncrblobHandle && !pCur->aOverflow ){
sl@0	3239	int nOvfl = (pCur->info.nPayload-pCur->info.nLocal+ovflSize-1)/ovflSize;
sl@0	3240	pCur->aOverflow = (Pgno )sqlite3MallocZero(sizeof(Pgno)nOvfl);
sl@0	3241	if( nOvfl && !pCur->aOverflow ){
sl@0	3242	rc = SQLITE_NOMEM;
sl@0	3243	}
sl@0	3244	}
sl@0	3245
sl@0	3246	/* If the overflow page-list cache has been allocated and the
sl@0	3247	** entry for the first required overflow page is valid, skip
sl@0	3248	** directly to it.
sl@0	3249	*/
sl@0	3250	if( pCur->aOverflow && pCur->aOverflow[offset/ovflSize] ){
sl@0	3251	iIdx = (offset/ovflSize);
sl@0	3252	nextPage = pCur->aOverflow[iIdx];
sl@0	3253	offset = (offset%ovflSize);
sl@0	3254	}
sl@0	3255	#endif
sl@0	3256
sl@0	3257	for( ; rc==SQLITE_OK && amt>0 && nextPage; iIdx++){
sl@0	3258
sl@0	3259	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	3260	/* If required, populate the overflow page-list cache. */
sl@0	3261	if( pCur->aOverflow ){
sl@0	3262	assert(!pCur->aOverflow[iIdx] \|\| pCur->aOverflow[iIdx]==nextPage);
sl@0	3263	pCur->aOverflow[iIdx] = nextPage;
sl@0	3264	}
sl@0	3265	#endif
sl@0	3266
sl@0	3267	if( offset>=ovflSize ){
sl@0	3268	/* The only reason to read this page is to obtain the page
sl@0	3269	** number for the next page in the overflow chain. The page
sl@0	3270	** data is not required. So first try to lookup the overflow
sl@0	3271	** page-list cache, if any, then fall back to the getOverflowPage()
sl@0	3272	** function.
sl@0	3273	*/
sl@0	3274	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	3275	if( pCur->aOverflow && pCur->aOverflow[iIdx+1] ){
sl@0	3276	nextPage = pCur->aOverflow[iIdx+1];
sl@0	3277	} else
sl@0	3278	#endif
sl@0	3279	rc = getOverflowPage(pBt, nextPage, 0, &nextPage);
sl@0	3280	offset -= ovflSize;
sl@0	3281	}else{
sl@0	3282	/* Need to read this page properly. It contains some of the
sl@0	3283	** range of data that is being read (eOp==0) or written (eOp!=0).
sl@0	3284	*/
sl@0	3285	DbPage *pDbPage;
sl@0	3286	int a = amt;
sl@0	3287	rc = sqlite3PagerGet(pBt->pPager, nextPage, &pDbPage);
sl@0	3288	if( rc==SQLITE_OK ){
sl@0	3289	aPayload = sqlite3PagerGetData(pDbPage);
sl@0	3290	nextPage = get4byte(aPayload);
sl@0	3291	if( a + offset > ovflSize ){
sl@0	3292	a = ovflSize - offset;
sl@0	3293	}
sl@0	3294	rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
sl@0	3295	sqlite3PagerUnref(pDbPage);
sl@0	3296	offset = 0;
sl@0	3297	amt -= a;
sl@0	3298	pBuf += a;
sl@0	3299	}
sl@0	3300	}
sl@0	3301	}
sl@0	3302	}
sl@0	3303
sl@0	3304	if( rc==SQLITE_OK && amt>0 ){
sl@0	3305	return SQLITE_CORRUPT_BKPT;
sl@0	3306	}
sl@0	3307	return rc;
sl@0	3308	}
sl@0	3309
sl@0	3310	/*
sl@0	3311	** Read part of the key associated with cursor pCur. Exactly
sl@0	3312	** "amt" bytes will be transfered into pBuf[]. The transfer
sl@0	3313	** begins at "offset".
sl@0	3314	**
sl@0	3315	** Return SQLITE_OK on success or an error code if anything goes
sl@0	3316	** wrong. An error is returned if "offset+amt" is larger than
sl@0	3317	** the available payload.
sl@0	3318	*/
sl@0	3319	int sqlite3BtreeKey(BtCursor pCur, u32 offset, u32 amt, void pBuf){
sl@0	3320	int rc;
sl@0	3321
sl@0	3322	assert( cursorHoldsMutex(pCur) );
sl@0	3323	rc = restoreCursorPosition(pCur);
sl@0	3324	if( rc==SQLITE_OK ){
sl@0	3325	assert( pCur->eState==CURSOR_VALID );
sl@0	3326	assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
sl@0	3327	if( pCur->apPage[0]->intKey ){
sl@0	3328	return SQLITE_CORRUPT_BKPT;
sl@0	3329	}
sl@0	3330	assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
sl@0	3331	rc = accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0, 0);
sl@0	3332	}
sl@0	3333	return rc;
sl@0	3334	}
sl@0	3335
sl@0	3336	/*
sl@0	3337	** Read part of the data associated with cursor pCur. Exactly
sl@0	3338	** "amt" bytes will be transfered into pBuf[]. The transfer
sl@0	3339	** begins at "offset".
sl@0	3340	**
sl@0	3341	** Return SQLITE_OK on success or an error code if anything goes
sl@0	3342	** wrong. An error is returned if "offset+amt" is larger than
sl@0	3343	** the available payload.
sl@0	3344	*/
sl@0	3345	int sqlite3BtreeData(BtCursor pCur, u32 offset, u32 amt, void pBuf){
sl@0	3346	int rc;
sl@0	3347
sl@0	3348	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	3349	if ( pCur->eState==CURSOR_INVALID ){
sl@0	3350	return SQLITE_ABORT;
sl@0	3351	}
sl@0	3352	#endif
sl@0	3353
sl@0	3354	assert( cursorHoldsMutex(pCur) );
sl@0	3355	rc = restoreCursorPosition(pCur);
sl@0	3356	if( rc==SQLITE_OK ){
sl@0	3357	assert( pCur->eState==CURSOR_VALID );
sl@0	3358	assert( pCur->iPage>=0 && pCur->apPage[pCur->iPage] );
sl@0	3359	assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
sl@0	3360	rc = accessPayload(pCur, offset, amt, pBuf, 1, 0);
sl@0	3361	}
sl@0	3362	return rc;
sl@0	3363	}
sl@0	3364
sl@0	3365	/*
sl@0	3366	** Return a pointer to payload information from the entry that the
sl@0	3367	** pCur cursor is pointing to. The pointer is to the beginning of
sl@0	3368	** the key if skipKey==0 and it points to the beginning of data if
sl@0	3369	** skipKey==1. The number of bytes of available key/data is written
sl@0	3370	** into pAmt. If pAmt==0, then the value returned will not be
sl@0	3371	** a valid pointer.
sl@0	3372	**
sl@0	3373	** This routine is an optimization. It is common for the entire key
sl@0	3374	** and data to fit on the local page and for there to be no overflow
sl@0	3375	** pages. When that is so, this routine can be used to access the
sl@0	3376	** key and data without making a copy. If the key and/or data spills
sl@0	3377	** onto overflow pages, then accessPayload() must be used to reassembly
sl@0	3378	** the key/data and copy it into a preallocated buffer.
sl@0	3379	**
sl@0	3380	** The pointer returned by this routine looks directly into the cached
sl@0	3381	** page of the database. The data might change or move the next time
sl@0	3382	** any btree routine is called.
sl@0	3383	*/
sl@0	3384	static const unsigned char *fetchPayload(
sl@0	3385	BtCursor pCur, / Cursor pointing to entry to read from */
sl@0	3386	int pAmt, / Write the number of available bytes here */
sl@0	3387	int skipKey /* read beginning at data if this is true */
sl@0	3388	){
sl@0	3389	unsigned char *aPayload;
sl@0	3390	MemPage *pPage;
sl@0	3391	u32 nKey;
sl@0	3392	int nLocal;
sl@0	3393
sl@0	3394	assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
sl@0	3395	assert( pCur->eState==CURSOR_VALID );
sl@0	3396	assert( cursorHoldsMutex(pCur) );
sl@0	3397	pPage = pCur->apPage[pCur->iPage];
sl@0	3398	assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
sl@0	3399	getCellInfo(pCur);
sl@0	3400	aPayload = pCur->info.pCell;
sl@0	3401	aPayload += pCur->info.nHeader;
sl@0	3402	if( pPage->intKey ){
sl@0	3403	nKey = 0;
sl@0	3404	}else{
sl@0	3405	nKey = pCur->info.nKey;
sl@0	3406	}
sl@0	3407	if( skipKey ){
sl@0	3408	aPayload += nKey;
sl@0	3409	nLocal = pCur->info.nLocal - nKey;
sl@0	3410	}else{
sl@0	3411	nLocal = pCur->info.nLocal;
sl@0	3412	if( nLocal>nKey ){
sl@0	3413	nLocal = nKey;
sl@0	3414	}
sl@0	3415	}
sl@0	3416	*pAmt = nLocal;
sl@0	3417	return aPayload;
sl@0	3418	}
sl@0	3419
sl@0	3420
sl@0	3421	/*
sl@0	3422	** For the entry that cursor pCur is point to, return as
sl@0	3423	** many bytes of the key or data as are available on the local
sl@0	3424	** b-tree page. Write the number of available bytes into *pAmt.
sl@0	3425	**
sl@0	3426	** The pointer returned is ephemeral. The key/data may move
sl@0	3427	** or be destroyed on the next call to any Btree routine,
sl@0	3428	** including calls from other threads against the same cache.
sl@0	3429	** Hence, a mutex on the BtShared should be held prior to calling
sl@0	3430	** this routine.
sl@0	3431	**
sl@0	3432	** These routines is used to get quick access to key and data
sl@0	3433	** in the common case where no overflow pages are used.
sl@0	3434	*/
sl@0	3435	const void sqlite3BtreeKeyFetch(BtCursor pCur, int *pAmt){
sl@0	3436	assert( cursorHoldsMutex(pCur) );
sl@0	3437	if( pCur->eState==CURSOR_VALID ){
sl@0	3438	return (const void*)fetchPayload(pCur, pAmt, 0);
sl@0	3439	}
sl@0	3440	return 0;
sl@0	3441	}
sl@0	3442	const void sqlite3BtreeDataFetch(BtCursor pCur, int *pAmt){
sl@0	3443	assert( cursorHoldsMutex(pCur) );
sl@0	3444	if( pCur->eState==CURSOR_VALID ){
sl@0	3445	return (const void*)fetchPayload(pCur, pAmt, 1);
sl@0	3446	}
sl@0	3447	return 0;
sl@0	3448	}
sl@0	3449
sl@0	3450
sl@0	3451	/*
sl@0	3452	** Move the cursor down to a new child page. The newPgno argument is the
sl@0	3453	** page number of the child page to move to.
sl@0	3454	*/
sl@0	3455	static int moveToChild(BtCursor *pCur, u32 newPgno){
sl@0	3456	int rc;
sl@0	3457	int i = pCur->iPage;
sl@0	3458	MemPage *pNewPage;
sl@0	3459	BtShared *pBt = pCur->pBt;
sl@0	3460
sl@0	3461	assert( cursorHoldsMutex(pCur) );
sl@0	3462	assert( pCur->eState==CURSOR_VALID );
sl@0	3463	assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
sl@0	3464	if( pCur->iPage>=(BTCURSOR_MAX_DEPTH-1) ){
sl@0	3465	return SQLITE_CORRUPT_BKPT;
sl@0	3466	}
sl@0	3467	rc = getAndInitPage(pBt, newPgno, &pNewPage);
sl@0	3468	if( rc ) return rc;
sl@0	3469	pCur->apPage[i+1] = pNewPage;
sl@0	3470	pCur->aiIdx[i+1] = 0;
sl@0	3471	pCur->iPage++;
sl@0	3472
sl@0	3473	pCur->info.nSize = 0;
sl@0	3474	pCur->validNKey = 0;
sl@0	3475	if( pNewPage->nCell<1 ){
sl@0	3476	return SQLITE_CORRUPT_BKPT;
sl@0	3477	}
sl@0	3478	return SQLITE_OK;
sl@0	3479	}
sl@0	3480
sl@0	3481	#ifndef NDEBUG
sl@0	3482	/*
sl@0	3483	** Page pParent is an internal (non-leaf) tree page. This function
sl@0	3484	** asserts that page number iChild is the left-child if the iIdx'th
sl@0	3485	** cell in page pParent. Or, if iIdx is equal to the total number of
sl@0	3486	** cells in pParent, that page number iChild is the right-child of
sl@0	3487	** the page.
sl@0	3488	*/
sl@0	3489	static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
sl@0	3490	assert( iIdx<=pParent->nCell );
sl@0	3491	if( iIdx==pParent->nCell ){
sl@0	3492	assert( get4byte(&pParent->aData[pParent->hdrOffset+8])==iChild );
sl@0	3493	}else{
sl@0	3494	assert( get4byte(findCell(pParent, iIdx))==iChild );
sl@0	3495	}
sl@0	3496	}
sl@0	3497	#else
sl@0	3498	# define assertParentIndex(x,y,z)
sl@0	3499	#endif
sl@0	3500
sl@0	3501	/*
sl@0	3502	** Move the cursor up to the parent page.
sl@0	3503	**
sl@0	3504	** pCur->idx is set to the cell index that contains the pointer
sl@0	3505	** to the page we are coming from. If we are coming from the
sl@0	3506	** right-most child page then pCur->idx is set to one more than
sl@0	3507	** the largest cell index.
sl@0	3508	*/
sl@0	3509	void sqlite3BtreeMoveToParent(BtCursor *pCur){
sl@0	3510	assert( cursorHoldsMutex(pCur) );
sl@0	3511	assert( pCur->eState==CURSOR_VALID );
sl@0	3512	assert( pCur->iPage>0 );
sl@0	3513	assert( pCur->apPage[pCur->iPage] );
sl@0	3514	assertParentIndex(
sl@0	3515	pCur->apPage[pCur->iPage-1],
sl@0	3516	pCur->aiIdx[pCur->iPage-1],
sl@0	3517	pCur->apPage[pCur->iPage]->pgno
sl@0	3518	);
sl@0	3519	releasePage(pCur->apPage[pCur->iPage]);
sl@0	3520	pCur->iPage--;
sl@0	3521	pCur->info.nSize = 0;
sl@0	3522	pCur->validNKey = 0;
sl@0	3523	}
sl@0	3524
sl@0	3525	/*
sl@0	3526	** Move the cursor to the root page
sl@0	3527	*/
sl@0	3528	static int moveToRoot(BtCursor *pCur){
sl@0	3529	MemPage *pRoot;
sl@0	3530	int rc = SQLITE_OK;
sl@0	3531	Btree *p = pCur->pBtree;
sl@0	3532	BtShared *pBt = p->pBt;
sl@0	3533
sl@0	3534	assert( cursorHoldsMutex(pCur) );
sl@0	3535	assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
sl@0	3536	assert( CURSOR_VALID < CURSOR_REQUIRESEEK );
sl@0	3537	assert( CURSOR_FAULT > CURSOR_REQUIRESEEK );
sl@0	3538	if( pCur->eState>=CURSOR_REQUIRESEEK ){
sl@0	3539	if( pCur->eState==CURSOR_FAULT ){
sl@0	3540	return pCur->skip;
sl@0	3541	}
sl@0	3542	sqlite3BtreeClearCursor(pCur);
sl@0	3543	}
sl@0	3544
sl@0	3545	if( pCur->iPage>=0 ){
sl@0	3546	int i;
sl@0	3547	for(i=1; i<=pCur->iPage; i++){
sl@0	3548	releasePage(pCur->apPage[i]);
sl@0	3549	}
sl@0	3550	}else{
sl@0	3551	if(
sl@0	3552	SQLITE_OK!=(rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->apPage[0]))
sl@0	3553	){
sl@0	3554	pCur->eState = CURSOR_INVALID;
sl@0	3555	return rc;
sl@0	3556	}
sl@0	3557	}
sl@0	3558
sl@0	3559	pRoot = pCur->apPage[0];
sl@0	3560	assert( pRoot->pgno==pCur->pgnoRoot );
sl@0	3561	pCur->iPage = 0;
sl@0	3562	pCur->aiIdx[0] = 0;
sl@0	3563	pCur->info.nSize = 0;
sl@0	3564	pCur->atLast = 0;
sl@0	3565	pCur->validNKey = 0;
sl@0	3566
sl@0	3567	if( pRoot->nCell==0 && !pRoot->leaf ){
sl@0	3568	Pgno subpage;
sl@0	3569	assert( pRoot->pgno==1 );
sl@0	3570	subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
sl@0	3571	assert( subpage>0 );
sl@0	3572	pCur->eState = CURSOR_VALID;
sl@0	3573	rc = moveToChild(pCur, subpage);
sl@0	3574	}else{
sl@0	3575	pCur->eState = ((pRoot->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
sl@0	3576	}
sl@0	3577	return rc;
sl@0	3578	}
sl@0	3579
sl@0	3580	/*
sl@0	3581	** Move the cursor down to the left-most leaf entry beneath the
sl@0	3582	** entry to which it is currently pointing.
sl@0	3583	**
sl@0	3584	** The left-most leaf is the one with the smallest key - the first
sl@0	3585	** in ascending order.
sl@0	3586	*/
sl@0	3587	static int moveToLeftmost(BtCursor *pCur){
sl@0	3588	Pgno pgno;
sl@0	3589	int rc = SQLITE_OK;
sl@0	3590	MemPage *pPage;
sl@0	3591
sl@0	3592	assert( cursorHoldsMutex(pCur) );
sl@0	3593	assert( pCur->eState==CURSOR_VALID );
sl@0	3594	while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
sl@0	3595	assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
sl@0	3596	pgno = get4byte(findCell(pPage, pCur->aiIdx[pCur->iPage]));
sl@0	3597	rc = moveToChild(pCur, pgno);
sl@0	3598	}
sl@0	3599	return rc;
sl@0	3600	}
sl@0	3601
sl@0	3602	/*
sl@0	3603	** Move the cursor down to the right-most leaf entry beneath the
sl@0	3604	** page to which it is currently pointing. Notice the difference
sl@0	3605	** between moveToLeftmost() and moveToRightmost(). moveToLeftmost()
sl@0	3606	** finds the left-most entry beneath the entry whereas moveToRightmost()
sl@0	3607	** finds the right-most entry beneath the page.
sl@0	3608	**
sl@0	3609	** The right-most entry is the one with the largest key - the last
sl@0	3610	** key in ascending order.
sl@0	3611	*/
sl@0	3612	static int moveToRightmost(BtCursor *pCur){
sl@0	3613	Pgno pgno;
sl@0	3614	int rc = SQLITE_OK;
sl@0	3615	MemPage *pPage;
sl@0	3616
sl@0	3617	assert( cursorHoldsMutex(pCur) );
sl@0	3618	assert( pCur->eState==CURSOR_VALID );
sl@0	3619	while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
sl@0	3620	pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
sl@0	3621	pCur->aiIdx[pCur->iPage] = pPage->nCell;
sl@0	3622	rc = moveToChild(pCur, pgno);
sl@0	3623	}
sl@0	3624	if( rc==SQLITE_OK ){
sl@0	3625	pCur->aiIdx[pCur->iPage] = pPage->nCell-1;
sl@0	3626	pCur->info.nSize = 0;
sl@0	3627	pCur->validNKey = 0;
sl@0	3628	}
sl@0	3629	return rc;
sl@0	3630	}
sl@0	3631
sl@0	3632	/* Move the cursor to the first entry in the table. Return SQLITE_OK
sl@0	3633	** on success. Set *pRes to 0 if the cursor actually points to something
sl@0	3634	** or set *pRes to 1 if the table is empty.
sl@0	3635	*/
sl@0	3636	int sqlite3BtreeFirst(BtCursor pCur, int pRes){
sl@0	3637	int rc;
sl@0	3638
sl@0	3639	assert( cursorHoldsMutex(pCur) );
sl@0	3640	assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
sl@0	3641	rc = moveToRoot(pCur);
sl@0	3642	if( rc==SQLITE_OK ){
sl@0	3643	if( pCur->eState==CURSOR_INVALID ){
sl@0	3644	assert( pCur->apPage[pCur->iPage]->nCell==0 );
sl@0	3645	*pRes = 1;
sl@0	3646	rc = SQLITE_OK;
sl@0	3647	}else{
sl@0	3648	assert( pCur->apPage[pCur->iPage]->nCell>0 );
sl@0	3649	*pRes = 0;
sl@0	3650	rc = moveToLeftmost(pCur);
sl@0	3651	}
sl@0	3652	}
sl@0	3653	return rc;
sl@0	3654	}
sl@0	3655
sl@0	3656	/* Move the cursor to the last entry in the table. Return SQLITE_OK
sl@0	3657	** on success. Set *pRes to 0 if the cursor actually points to something
sl@0	3658	** or set *pRes to 1 if the table is empty.
sl@0	3659	*/
sl@0	3660	int sqlite3BtreeLast(BtCursor pCur, int pRes){
sl@0	3661	int rc;
sl@0	3662
sl@0	3663	assert( cursorHoldsMutex(pCur) );
sl@0	3664	assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
sl@0	3665	rc = moveToRoot(pCur);
sl@0	3666	if( rc==SQLITE_OK ){
sl@0	3667	if( CURSOR_INVALID==pCur->eState ){
sl@0	3668	assert( pCur->apPage[pCur->iPage]->nCell==0 );
sl@0	3669	*pRes = 1;
sl@0	3670	}else{
sl@0	3671	assert( pCur->eState==CURSOR_VALID );
sl@0	3672	*pRes = 0;
sl@0	3673	rc = moveToRightmost(pCur);
sl@0	3674	getCellInfo(pCur);
sl@0	3675	pCur->atLast = rc==SQLITE_OK;
sl@0	3676	}
sl@0	3677	}
sl@0	3678	return rc;
sl@0	3679	}
sl@0	3680
sl@0	3681	/* Move the cursor so that it points to an entry near the key
sl@0	3682	** specified by pIdxKey or intKey. Return a success code.
sl@0	3683	**
sl@0	3684	** For INTKEY tables, the intKey parameter is used. pIdxKey
sl@0	3685	** must be NULL. For index tables, pIdxKey is used and intKey
sl@0	3686	** is ignored.
sl@0	3687	**
sl@0	3688	** If an exact match is not found, then the cursor is always
sl@0	3689	** left pointing at a leaf page which would hold the entry if it
sl@0	3690	** were present. The cursor might point to an entry that comes
sl@0	3691	** before or after the key.
sl@0	3692	**
sl@0	3693	** The result of comparing the key with the entry to which the
sl@0	3694	** cursor is written to *pRes if pRes!=NULL. The meaning of
sl@0	3695	** this value is as follows:
sl@0	3696	**
sl@0	3697	** *pRes<0 The cursor is left pointing at an entry that
sl@0	3698	** is smaller than pKey or if the table is empty
sl@0	3699	** and the cursor is therefore left point to nothing.
sl@0	3700	**
sl@0	3701	** *pRes==0 The cursor is left pointing at an entry that
sl@0	3702	** exactly matches pKey.
sl@0	3703	**
sl@0	3704	** *pRes>0 The cursor is left pointing at an entry that
sl@0	3705	** is larger than pKey.
sl@0	3706	**
sl@0	3707	*/
sl@0	3708	int sqlite3BtreeMovetoUnpacked(
sl@0	3709	BtCursor pCur, / The cursor to be moved */
sl@0	3710	UnpackedRecord pIdxKey, / Unpacked index key */
sl@0	3711	i64 intKey, /* The table key */
sl@0	3712	int biasRight, /* If true, bias the search to the high end */
sl@0	3713	int pRes / Write search results here */
sl@0	3714	){
sl@0	3715	int rc;
sl@0	3716
sl@0	3717	assert( cursorHoldsMutex(pCur) );
sl@0	3718	assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
sl@0	3719
sl@0	3720	/* If the cursor is already positioned at the point we are trying
sl@0	3721	** to move to, then just return without doing any work */
sl@0	3722	if( pCur->eState==CURSOR_VALID && pCur->validNKey
sl@0	3723	&& pCur->apPage[0]->intKey
sl@0	3724	){
sl@0	3725	if( pCur->info.nKey==intKey ){
sl@0	3726	*pRes = 0;
sl@0	3727	return SQLITE_OK;
sl@0	3728	}
sl@0	3729	if( pCur->atLast && pCur->info.nKey<intKey ){
sl@0	3730	*pRes = -1;
sl@0	3731	return SQLITE_OK;
sl@0	3732	}
sl@0	3733	}
sl@0	3734
sl@0	3735	rc = moveToRoot(pCur);
sl@0	3736	if( rc ){
sl@0	3737	return rc;
sl@0	3738	}
sl@0	3739	assert( pCur->apPage[pCur->iPage] );
sl@0	3740	assert( pCur->apPage[pCur->iPage]->isInit );
sl@0	3741	if( pCur->eState==CURSOR_INVALID ){
sl@0	3742	*pRes = -1;
sl@0	3743	assert( pCur->apPage[pCur->iPage]->nCell==0 );
sl@0	3744	return SQLITE_OK;
sl@0	3745	}
sl@0	3746	assert( pCur->apPage[0]->intKey \|\| pIdxKey );
sl@0	3747	for(;;){
sl@0	3748	int lwr, upr;
sl@0	3749	Pgno chldPg;
sl@0	3750	MemPage *pPage = pCur->apPage[pCur->iPage];
sl@0	3751	int c = -1; /* pRes return if table is empty must be -1 */
sl@0	3752	lwr = 0;
sl@0	3753	upr = pPage->nCell-1;
sl@0	3754	if( !pPage->intKey && pIdxKey==0 ){
sl@0	3755	rc = SQLITE_CORRUPT_BKPT;
sl@0	3756	goto moveto_finish;
sl@0	3757	}
sl@0	3758	if( biasRight ){
sl@0	3759	pCur->aiIdx[pCur->iPage] = upr;
sl@0	3760	}else{
sl@0	3761	pCur->aiIdx[pCur->iPage] = (upr+lwr)/2;
sl@0	3762	}
sl@0	3763	if( lwr<=upr ) for(;;){
sl@0	3764	void *pCellKey;
sl@0	3765	i64 nCellKey;
sl@0	3766	int idx = pCur->aiIdx[pCur->iPage];
sl@0	3767	pCur->info.nSize = 0;
sl@0	3768	pCur->validNKey = 1;
sl@0	3769	if( pPage->intKey ){
sl@0	3770	u8 *pCell;
sl@0	3771	pCell = findCell(pPage, idx) + pPage->childPtrSize;
sl@0	3772	if( pPage->hasData ){
sl@0	3773	u32 dummy;
sl@0	3774	pCell += getVarint32(pCell, dummy);
sl@0	3775	}
sl@0	3776	getVarint(pCell, (u64*)&nCellKey);
sl@0	3777	if( nCellKey==intKey ){
sl@0	3778	c = 0;
sl@0	3779	}else if( nCellKey<intKey ){
sl@0	3780	c = -1;
sl@0	3781	}else{
sl@0	3782	assert( nCellKey>intKey );
sl@0	3783	c = +1;
sl@0	3784	}
sl@0	3785	}else{
sl@0	3786	int available;
sl@0	3787	pCellKey = (void *)fetchPayload(pCur, &available, 0);
sl@0	3788	nCellKey = pCur->info.nKey;
sl@0	3789	if( available>=nCellKey ){
sl@0	3790	c = sqlite3VdbeRecordCompare(nCellKey, pCellKey, pIdxKey);
sl@0	3791	}else{
sl@0	3792	pCellKey = sqlite3Malloc( nCellKey );
sl@0	3793	if( pCellKey==0 ){
sl@0	3794	rc = SQLITE_NOMEM;
sl@0	3795	goto moveto_finish;
sl@0	3796	}
sl@0	3797	rc = sqlite3BtreeKey(pCur, 0, nCellKey, (void *)pCellKey);
sl@0	3798	c = sqlite3VdbeRecordCompare(nCellKey, pCellKey, pIdxKey);
sl@0	3799	sqlite3_free(pCellKey);
sl@0	3800	if( rc ) goto moveto_finish;
sl@0	3801	}
sl@0	3802	}
sl@0	3803	if( c==0 ){
sl@0	3804	pCur->info.nKey = nCellKey;
sl@0	3805	if( pPage->intKey && !pPage->leaf ){
sl@0	3806	lwr = idx;
sl@0	3807	upr = lwr - 1;
sl@0	3808	break;
sl@0	3809	}else{
sl@0	3810	if( pRes ) *pRes = 0;
sl@0	3811	rc = SQLITE_OK;
sl@0	3812	goto moveto_finish;
sl@0	3813	}
sl@0	3814	}
sl@0	3815	if( c<0 ){
sl@0	3816	lwr = idx+1;
sl@0	3817	}else{
sl@0	3818	upr = idx-1;
sl@0	3819	}
sl@0	3820	if( lwr>upr ){
sl@0	3821	pCur->info.nKey = nCellKey;
sl@0	3822	break;
sl@0	3823	}
sl@0	3824	pCur->aiIdx[pCur->iPage] = (lwr+upr)/2;
sl@0	3825	}
sl@0	3826	assert( lwr==upr+1 );
sl@0	3827	assert( pPage->isInit );
sl@0	3828	if( pPage->leaf ){
sl@0	3829	chldPg = 0;
sl@0	3830	}else if( lwr>=pPage->nCell ){
sl@0	3831	chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
sl@0	3832	}else{
sl@0	3833	chldPg = get4byte(findCell(pPage, lwr));
sl@0	3834	}
sl@0	3835	if( chldPg==0 ){
sl@0	3836	assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
sl@0	3837	if( pRes ) *pRes = c;
sl@0	3838	rc = SQLITE_OK;
sl@0	3839	goto moveto_finish;
sl@0	3840	}
sl@0	3841	pCur->aiIdx[pCur->iPage] = lwr;
sl@0	3842	pCur->info.nSize = 0;
sl@0	3843	pCur->validNKey = 0;
sl@0	3844	rc = moveToChild(pCur, chldPg);
sl@0	3845	if( rc ) goto moveto_finish;
sl@0	3846	}
sl@0	3847	moveto_finish:
sl@0	3848	return rc;
sl@0	3849	}
sl@0	3850
sl@0	3851	/*
sl@0	3852	** In this version of BtreeMoveto, pKey is a packed index record
sl@0	3853	** such as is generated by the OP_MakeRecord opcode. Unpack the
sl@0	3854	** record and then call BtreeMovetoUnpacked() to do the work.
sl@0	3855	*/
sl@0	3856	int sqlite3BtreeMoveto(
sl@0	3857	BtCursor pCur, / Cursor open on the btree to be searched */
sl@0	3858	const void pKey, / Packed key if the btree is an index */
sl@0	3859	i64 nKey, /* Integer key for tables. Size of pKey for indices */
sl@0	3860	int bias, /* Bias search to the high end */
sl@0	3861	int pRes / Write search results here */
sl@0	3862	){
sl@0	3863	int rc; /* Status code */
sl@0	3864	UnpackedRecord pIdxKey; / Unpacked index key */
sl@0	3865	UnpackedRecord aSpace[16]; /* Temp space for pIdxKey - to avoid a malloc */
sl@0	3866
sl@0	3867	if( pKey ){
sl@0	3868	pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, nKey, pKey,
sl@0	3869	aSpace, sizeof(aSpace));
sl@0	3870	if( pIdxKey==0 ) return SQLITE_NOMEM;
sl@0	3871	}else{
sl@0	3872	pIdxKey = 0;
sl@0	3873	}
sl@0	3874	rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
sl@0	3875	if( pKey ){
sl@0	3876	sqlite3VdbeDeleteUnpackedRecord(pIdxKey);
sl@0	3877	}
sl@0	3878	return rc;
sl@0	3879	}
sl@0	3880
sl@0	3881
sl@0	3882	/*
sl@0	3883	** Return TRUE if the cursor is not pointing at an entry of the table.
sl@0	3884	**
sl@0	3885	** TRUE will be returned after a call to sqlite3BtreeNext() moves
sl@0	3886	** past the last entry in the table or sqlite3BtreePrev() moves past
sl@0	3887	** the first entry. TRUE is also returned if the table is empty.
sl@0	3888	*/
sl@0	3889	int sqlite3BtreeEof(BtCursor *pCur){
sl@0	3890	/* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
sl@0	3891	** have been deleted? This API will need to change to return an error code
sl@0	3892	** as well as the boolean result value.
sl@0	3893	*/
sl@0	3894	return (CURSOR_VALID!=pCur->eState);
sl@0	3895	}
sl@0	3896
sl@0	3897	/*
sl@0	3898	** Return the database connection handle for a cursor.
sl@0	3899	*/
sl@0	3900	sqlite3 sqlite3BtreeCursorDb(const BtCursor pCur){
sl@0	3901	assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
sl@0	3902	return pCur->pBtree->db;
sl@0	3903	}
sl@0	3904
sl@0	3905	/*
sl@0	3906	** Advance the cursor to the next entry in the database. If
sl@0	3907	** successful then set *pRes=0. If the cursor
sl@0	3908	** was already pointing to the last entry in the database before
sl@0	3909	** this routine was called, then set *pRes=1.
sl@0	3910	*/
sl@0	3911	int sqlite3BtreeNext(BtCursor pCur, int pRes){
sl@0	3912	int rc;
sl@0	3913	int idx;
sl@0	3914	MemPage *pPage;
sl@0	3915
sl@0	3916	assert( cursorHoldsMutex(pCur) );
sl@0	3917	rc = restoreCursorPosition(pCur);
sl@0	3918	if( rc!=SQLITE_OK ){
sl@0	3919	return rc;
sl@0	3920	}
sl@0	3921	assert( pRes!=0 );
sl@0	3922	if( CURSOR_INVALID==pCur->eState ){
sl@0	3923	*pRes = 1;
sl@0	3924	return SQLITE_OK;
sl@0	3925	}
sl@0	3926	if( pCur->skip>0 ){
sl@0	3927	pCur->skip = 0;
sl@0	3928	*pRes = 0;
sl@0	3929	return SQLITE_OK;
sl@0	3930	}
sl@0	3931	pCur->skip = 0;
sl@0	3932
sl@0	3933	pPage = pCur->apPage[pCur->iPage];
sl@0	3934	idx = ++pCur->aiIdx[pCur->iPage];
sl@0	3935	assert( pPage->isInit );
sl@0	3936	assert( idx<=pPage->nCell );
sl@0	3937
sl@0	3938	pCur->info.nSize = 0;
sl@0	3939	pCur->validNKey = 0;
sl@0	3940	if( idx>=pPage->nCell ){
sl@0	3941	if( !pPage->leaf ){
sl@0	3942	rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
sl@0	3943	if( rc ) return rc;
sl@0	3944	rc = moveToLeftmost(pCur);
sl@0	3945	*pRes = 0;
sl@0	3946	return rc;
sl@0	3947	}
sl@0	3948	do{
sl@0	3949	if( pCur->iPage==0 ){
sl@0	3950	*pRes = 1;
sl@0	3951	pCur->eState = CURSOR_INVALID;
sl@0	3952	return SQLITE_OK;
sl@0	3953	}
sl@0	3954	sqlite3BtreeMoveToParent(pCur);
sl@0	3955	pPage = pCur->apPage[pCur->iPage];
sl@0	3956	}while( pCur->aiIdx[pCur->iPage]>=pPage->nCell );
sl@0	3957	*pRes = 0;
sl@0	3958	if( pPage->intKey ){
sl@0	3959	rc = sqlite3BtreeNext(pCur, pRes);
sl@0	3960	}else{
sl@0	3961	rc = SQLITE_OK;
sl@0	3962	}
sl@0	3963	return rc;
sl@0	3964	}
sl@0	3965	*pRes = 0;
sl@0	3966	if( pPage->leaf ){
sl@0	3967	return SQLITE_OK;
sl@0	3968	}
sl@0	3969	rc = moveToLeftmost(pCur);
sl@0	3970	return rc;
sl@0	3971	}
sl@0	3972
sl@0	3973
sl@0	3974	/*
sl@0	3975	** Step the cursor to the back to the previous entry in the database. If
sl@0	3976	** successful then set *pRes=0. If the cursor
sl@0	3977	** was already pointing to the first entry in the database before
sl@0	3978	** this routine was called, then set *pRes=1.
sl@0	3979	*/
sl@0	3980	int sqlite3BtreePrevious(BtCursor pCur, int pRes){
sl@0	3981	int rc;
sl@0	3982	MemPage *pPage;
sl@0	3983
sl@0	3984	assert( cursorHoldsMutex(pCur) );
sl@0	3985	rc = restoreCursorPosition(pCur);
sl@0	3986	if( rc!=SQLITE_OK ){
sl@0	3987	return rc;
sl@0	3988	}
sl@0	3989	pCur->atLast = 0;
sl@0	3990	if( CURSOR_INVALID==pCur->eState ){
sl@0	3991	*pRes = 1;
sl@0	3992	return SQLITE_OK;
sl@0	3993	}
sl@0	3994	if( pCur->skip<0 ){
sl@0	3995	pCur->skip = 0;
sl@0	3996	*pRes = 0;
sl@0	3997	return SQLITE_OK;
sl@0	3998	}
sl@0	3999	pCur->skip = 0;
sl@0	4000
sl@0	4001	pPage = pCur->apPage[pCur->iPage];
sl@0	4002	assert( pPage->isInit );
sl@0	4003	if( !pPage->leaf ){
sl@0	4004	int idx = pCur->aiIdx[pCur->iPage];
sl@0	4005	rc = moveToChild(pCur, get4byte(findCell(pPage, idx)));
sl@0	4006	if( rc ){
sl@0	4007	return rc;
sl@0	4008	}
sl@0	4009	rc = moveToRightmost(pCur);
sl@0	4010	}else{
sl@0	4011	while( pCur->aiIdx[pCur->iPage]==0 ){
sl@0	4012	if( pCur->iPage==0 ){
sl@0	4013	pCur->eState = CURSOR_INVALID;
sl@0	4014	*pRes = 1;
sl@0	4015	return SQLITE_OK;
sl@0	4016	}
sl@0	4017	sqlite3BtreeMoveToParent(pCur);
sl@0	4018	}
sl@0	4019	pCur->info.nSize = 0;
sl@0	4020	pCur->validNKey = 0;
sl@0	4021
sl@0	4022	pCur->aiIdx[pCur->iPage]--;
sl@0	4023	pPage = pCur->apPage[pCur->iPage];
sl@0	4024	if( pPage->intKey && !pPage->leaf ){
sl@0	4025	rc = sqlite3BtreePrevious(pCur, pRes);
sl@0	4026	}else{
sl@0	4027	rc = SQLITE_OK;
sl@0	4028	}
sl@0	4029	}
sl@0	4030	*pRes = 0;
sl@0	4031	return rc;
sl@0	4032	}
sl@0	4033
sl@0	4034	/*
sl@0	4035	** Allocate a new page from the database file.
sl@0	4036	**
sl@0	4037	** The new page is marked as dirty. (In other words, sqlite3PagerWrite()
sl@0	4038	** has already been called on the new page.) The new page has also
sl@0	4039	** been referenced and the calling routine is responsible for calling
sl@0	4040	** sqlite3PagerUnref() on the new page when it is done.
sl@0	4041	**
sl@0	4042	** SQLITE_OK is returned on success. Any other return value indicates
sl@0	4043	** an error. ppPage and pPgno are undefined in the event of an error.
sl@0	4044	** Do not invoke sqlite3PagerUnref() on *ppPage if an error is returned.
sl@0	4045	**
sl@0	4046	** If the "nearby" parameter is not 0, then a (feeble) effort is made to
sl@0	4047	** locate a page close to the page number "nearby". This can be used in an
sl@0	4048	** attempt to keep related pages close to each other in the database file,
sl@0	4049	** which in turn can make database access faster.
sl@0	4050	**
sl@0	4051	** If the "exact" parameter is not 0, and the page-number nearby exists
sl@0	4052	** anywhere on the free-list, then it is guarenteed to be returned. This
sl@0	4053	** is only used by auto-vacuum databases when allocating a new table.
sl@0	4054	*/
sl@0	4055	static int allocateBtreePage(
sl@0	4056	BtShared *pBt,
sl@0	4057	MemPage **ppPage,
sl@0	4058	Pgno *pPgno,
sl@0	4059	Pgno nearby,
sl@0	4060	u8 exact
sl@0	4061	){
sl@0	4062	MemPage *pPage1;
sl@0	4063	int rc;
sl@0	4064	int n; /* Number of pages on the freelist */
sl@0	4065	int k; /* Number of leaves on the trunk of the freelist */
sl@0	4066	MemPage *pTrunk = 0;
sl@0	4067	MemPage *pPrevTrunk = 0;
sl@0	4068
sl@0	4069	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	4070	pPage1 = pBt->pPage1;
sl@0	4071	n = get4byte(&pPage1->aData[36]);
sl@0	4072	if( n>0 ){
sl@0	4073	/* There are pages on the freelist. Reuse one of those pages. */
sl@0	4074	Pgno iTrunk;
sl@0	4075	u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
sl@0	4076
sl@0	4077	/* If the 'exact' parameter was true and a query of the pointer-map
sl@0	4078	** shows that the page 'nearby' is somewhere on the free-list, then
sl@0	4079	** the entire-list will be searched for that page.
sl@0	4080	*/
sl@0	4081	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	4082	if( exact && nearby<=pagerPagecount(pBt->pPager) ){
sl@0	4083	u8 eType;
sl@0	4084	assert( nearby>0 );
sl@0	4085	assert( pBt->autoVacuum );
sl@0	4086	rc = ptrmapGet(pBt, nearby, &eType, 0);
sl@0	4087	if( rc ) return rc;
sl@0	4088	if( eType==PTRMAP_FREEPAGE ){
sl@0	4089	searchList = 1;
sl@0	4090	}
sl@0	4091	*pPgno = nearby;
sl@0	4092	}
sl@0	4093	#endif
sl@0	4094
sl@0	4095	/* Decrement the free-list count by 1. Set iTrunk to the index of the
sl@0	4096	** first free-list trunk page. iPrevTrunk is initially 1.
sl@0	4097	*/
sl@0	4098	rc = sqlite3PagerWrite(pPage1->pDbPage);
sl@0	4099	if( rc ) return rc;
sl@0	4100	put4byte(&pPage1->aData[36], n-1);
sl@0	4101
sl@0	4102	/* The code within this loop is run only once if the 'searchList' variable
sl@0	4103	** is not true. Otherwise, it runs once for each trunk-page on the
sl@0	4104	** free-list until the page 'nearby' is located.
sl@0	4105	*/
sl@0	4106	do {
sl@0	4107	pPrevTrunk = pTrunk;
sl@0	4108	if( pPrevTrunk ){
sl@0	4109	iTrunk = get4byte(&pPrevTrunk->aData[0]);
sl@0	4110	}else{
sl@0	4111	iTrunk = get4byte(&pPage1->aData[32]);
sl@0	4112	}
sl@0	4113	rc = sqlite3BtreeGetPage(pBt, iTrunk, &pTrunk, 0);
sl@0	4114	if( rc ){
sl@0	4115	pTrunk = 0;
sl@0	4116	goto end_allocate_page;
sl@0	4117	}
sl@0	4118
sl@0	4119	k = get4byte(&pTrunk->aData[4]);
sl@0	4120	if( k==0 && !searchList ){
sl@0	4121	/* The trunk has no leaves and the list is not being searched.
sl@0	4122	** So extract the trunk page itself and use it as the newly
sl@0	4123	** allocated page */
sl@0	4124	assert( pPrevTrunk==0 );
sl@0	4125	rc = sqlite3PagerWrite(pTrunk->pDbPage);
sl@0	4126	if( rc ){
sl@0	4127	goto end_allocate_page;
sl@0	4128	}
sl@0	4129	*pPgno = iTrunk;
sl@0	4130	memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
sl@0	4131	*ppPage = pTrunk;
sl@0	4132	pTrunk = 0;
sl@0	4133	TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
sl@0	4134	}else if( k>pBt->usableSize/4 - 2 ){
sl@0	4135	/* Value of k is out of range. Database corruption */
sl@0	4136	rc = SQLITE_CORRUPT_BKPT;
sl@0	4137	goto end_allocate_page;
sl@0	4138	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	4139	}else if( searchList && nearby==iTrunk ){
sl@0	4140	/* The list is being searched and this trunk page is the page
sl@0	4141	** to allocate, regardless of whether it has leaves.
sl@0	4142	*/
sl@0	4143	assert( *pPgno==iTrunk );
sl@0	4144	*ppPage = pTrunk;
sl@0	4145	searchList = 0;
sl@0	4146	rc = sqlite3PagerWrite(pTrunk->pDbPage);
sl@0	4147	if( rc ){
sl@0	4148	goto end_allocate_page;
sl@0	4149	}
sl@0	4150	if( k==0 ){
sl@0	4151	if( !pPrevTrunk ){
sl@0	4152	memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
sl@0	4153	}else{
sl@0	4154	memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
sl@0	4155	}
sl@0	4156	}else{
sl@0	4157	/* The trunk page is required by the caller but it contains
sl@0	4158	** pointers to free-list leaves. The first leaf becomes a trunk
sl@0	4159	** page in this case.
sl@0	4160	*/
sl@0	4161	MemPage *pNewTrunk;
sl@0	4162	Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
sl@0	4163	rc = sqlite3BtreeGetPage(pBt, iNewTrunk, &pNewTrunk, 0);
sl@0	4164	if( rc!=SQLITE_OK ){
sl@0	4165	goto end_allocate_page;
sl@0	4166	}
sl@0	4167	rc = sqlite3PagerWrite(pNewTrunk->pDbPage);
sl@0	4168	if( rc!=SQLITE_OK ){
sl@0	4169	releasePage(pNewTrunk);
sl@0	4170	goto end_allocate_page;
sl@0	4171	}
sl@0	4172	memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
sl@0	4173	put4byte(&pNewTrunk->aData[4], k-1);
sl@0	4174	memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
sl@0	4175	releasePage(pNewTrunk);
sl@0	4176	if( !pPrevTrunk ){
sl@0	4177	put4byte(&pPage1->aData[32], iNewTrunk);
sl@0	4178	}else{
sl@0	4179	rc = sqlite3PagerWrite(pPrevTrunk->pDbPage);
sl@0	4180	if( rc ){
sl@0	4181	goto end_allocate_page;
sl@0	4182	}
sl@0	4183	put4byte(&pPrevTrunk->aData[0], iNewTrunk);
sl@0	4184	}
sl@0	4185	}
sl@0	4186	pTrunk = 0;
sl@0	4187	TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
sl@0	4188	#endif
sl@0	4189	}else{
sl@0	4190	/* Extract a leaf from the trunk */
sl@0	4191	int closest;
sl@0	4192	Pgno iPage;
sl@0	4193	unsigned char *aData = pTrunk->aData;
sl@0	4194	rc = sqlite3PagerWrite(pTrunk->pDbPage);
sl@0	4195	if( rc ){
sl@0	4196	goto end_allocate_page;
sl@0	4197	}
sl@0	4198	if( nearby>0 ){
sl@0	4199	int i, dist;
sl@0	4200	closest = 0;
sl@0	4201	dist = get4byte(&aData[8]) - nearby;
sl@0	4202	if( dist<0 ) dist = -dist;
sl@0	4203	for(i=1; i<k; i++){
sl@0	4204	int d2 = get4byte(&aData[8+i*4]) - nearby;
sl@0	4205	if( d2<0 ) d2 = -d2;
sl@0	4206	if( d2<dist ){
sl@0	4207	closest = i;
sl@0	4208	dist = d2;
sl@0	4209	}
sl@0	4210	}
sl@0	4211	}else{
sl@0	4212	closest = 0;
sl@0	4213	}
sl@0	4214
sl@0	4215	iPage = get4byte(&aData[8+closest*4]);
sl@0	4216	if( !searchList \|\| iPage==nearby ){
sl@0	4217	int nPage;
sl@0	4218	*pPgno = iPage;
sl@0	4219	nPage = pagerPagecount(pBt->pPager);
sl@0	4220	if( *pPgno>nPage ){
sl@0	4221	/* Free page off the end of the file */
sl@0	4222	rc = SQLITE_CORRUPT_BKPT;
sl@0	4223	goto end_allocate_page;
sl@0	4224	}
sl@0	4225	TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
sl@0	4226	": %d more free pages\n",
sl@0	4227	*pPgno, closest+1, k, pTrunk->pgno, n-1));
sl@0	4228	if( closest<k-1 ){
sl@0	4229	memcpy(&aData[8+closest4], &aData[4+k4], 4);
sl@0	4230	}
sl@0	4231	put4byte(&aData[4], k-1);
sl@0	4232	rc = sqlite3BtreeGetPage(pBt, *pPgno, ppPage, 1);
sl@0	4233	if( rc==SQLITE_OK ){
sl@0	4234	sqlite3PagerDontRollback((*ppPage)->pDbPage);
sl@0	4235	rc = sqlite3PagerWrite((*ppPage)->pDbPage);
sl@0	4236	if( rc!=SQLITE_OK ){
sl@0	4237	releasePage(*ppPage);
sl@0	4238	}
sl@0	4239	}
sl@0	4240	searchList = 0;
sl@0	4241	}
sl@0	4242	}
sl@0	4243	releasePage(pPrevTrunk);
sl@0	4244	pPrevTrunk = 0;
sl@0	4245	}while( searchList );
sl@0	4246	}else{
sl@0	4247	/* There are no pages on the freelist, so create a new page at the
sl@0	4248	** end of the file */
sl@0	4249	int nPage = pagerPagecount(pBt->pPager);
sl@0	4250	*pPgno = nPage + 1;
sl@0	4251
sl@0	4252	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	4253	if( pBt->nTrunc ){
sl@0	4254	/* An incr-vacuum has already run within this transaction. So the
sl@0	4255	** page to allocate is not from the physical end of the file, but
sl@0	4256	** at pBt->nTrunc.
sl@0	4257	*/
sl@0	4258	*pPgno = pBt->nTrunc+1;
sl@0	4259	if( *pPgno==PENDING_BYTE_PAGE(pBt) ){
sl@0	4260	(*pPgno)++;
sl@0	4261	}
sl@0	4262	}
sl@0	4263	if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){
sl@0	4264	/* If *pPgno refers to a pointer-map page, allocate two new pages
sl@0	4265	** at the end of the file instead of one. The first allocated page
sl@0	4266	** becomes a new pointer-map page, the second is used by the caller.
sl@0	4267	*/
sl@0	4268	TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", *pPgno));
sl@0	4269	assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
sl@0	4270	(*pPgno)++;
sl@0	4271	if( pPgno==PENDING_BYTE_PAGE(pBt) ){ (pPgno)++; }
sl@0	4272	}
sl@0	4273	if( pBt->nTrunc ){
sl@0	4274	pBt->nTrunc = *pPgno;
sl@0	4275	}
sl@0	4276	#endif
sl@0	4277
sl@0	4278	assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
sl@0	4279	rc = sqlite3BtreeGetPage(pBt, *pPgno, ppPage, 0);
sl@0	4280	if( rc ) return rc;
sl@0	4281	rc = sqlite3PagerWrite((*ppPage)->pDbPage);
sl@0	4282	if( rc!=SQLITE_OK ){
sl@0	4283	releasePage(*ppPage);
sl@0	4284	}
sl@0	4285	TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
sl@0	4286	}
sl@0	4287
sl@0	4288	assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
sl@0	4289
sl@0	4290	end_allocate_page:
sl@0	4291	releasePage(pTrunk);
sl@0	4292	releasePage(pPrevTrunk);
sl@0	4293	if( rc==SQLITE_OK ){
sl@0	4294	if( sqlite3PagerPageRefcount((*ppPage)->pDbPage)>1 ){
sl@0	4295	releasePage(*ppPage);
sl@0	4296	return SQLITE_CORRUPT_BKPT;
sl@0	4297	}
sl@0	4298	(*ppPage)->isInit = 0;
sl@0	4299	}
sl@0	4300	return rc;
sl@0	4301	}
sl@0	4302
sl@0	4303	/*
sl@0	4304	** Add a page of the database file to the freelist.
sl@0	4305	**
sl@0	4306	** sqlite3PagerUnref() is NOT called for pPage.
sl@0	4307	*/
sl@0	4308	static int freePage(MemPage *pPage){
sl@0	4309	BtShared *pBt = pPage->pBt;
sl@0	4310	MemPage *pPage1 = pBt->pPage1;
sl@0	4311	int rc, n, k;
sl@0	4312
sl@0	4313	/* Prepare the page for freeing */
sl@0	4314	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4315	assert( pPage->pgno>1 );
sl@0	4316	pPage->isInit = 0;
sl@0	4317
sl@0	4318	/* Increment the free page count on pPage1 */
sl@0	4319	rc = sqlite3PagerWrite(pPage1->pDbPage);
sl@0	4320	if( rc ) return rc;
sl@0	4321	n = get4byte(&pPage1->aData[36]);
sl@0	4322	put4byte(&pPage1->aData[36], n+1);
sl@0	4323
sl@0	4324	#ifdef SQLITE_SECURE_DELETE
sl@0	4325	/* If the SQLITE_SECURE_DELETE compile-time option is enabled, then
sl@0	4326	** always fully overwrite deleted information with zeros.
sl@0	4327	*/
sl@0	4328	rc = sqlite3PagerWrite(pPage->pDbPage);
sl@0	4329	if( rc ) return rc;
sl@0	4330	memset(pPage->aData, 0, pPage->pBt->pageSize);
sl@0	4331	#endif
sl@0	4332
sl@0	4333	/* If the database supports auto-vacuum, write an entry in the pointer-map
sl@0	4334	** to indicate that the page is free.
sl@0	4335	*/
sl@0	4336	if( ISAUTOVACUUM ){
sl@0	4337	rc = ptrmapPut(pBt, pPage->pgno, PTRMAP_FREEPAGE, 0);
sl@0	4338	if( rc ) return rc;
sl@0	4339	}
sl@0	4340
sl@0	4341	if( n==0 ){
sl@0	4342	/* This is the first free page */
sl@0	4343	rc = sqlite3PagerWrite(pPage->pDbPage);
sl@0	4344	if( rc ) return rc;
sl@0	4345	memset(pPage->aData, 0, 8);
sl@0	4346	put4byte(&pPage1->aData[32], pPage->pgno);
sl@0	4347	TRACE(("FREE-PAGE: %d first\n", pPage->pgno));
sl@0	4348	}else{
sl@0	4349	/* Other free pages already exist. Retrive the first trunk page
sl@0	4350	** of the freelist and find out how many leaves it has. */
sl@0	4351	MemPage *pTrunk;
sl@0	4352	rc = sqlite3BtreeGetPage(pBt, get4byte(&pPage1->aData[32]), &pTrunk, 0);
sl@0	4353	if( rc ) return rc;
sl@0	4354	k = get4byte(&pTrunk->aData[4]);
sl@0	4355	if( k>=pBt->usableSize/4 - 8 ){
sl@0	4356	/* The trunk is full. Turn the page being freed into a new
sl@0	4357	** trunk page with no leaves.
sl@0	4358	**
sl@0	4359	** Note that the trunk page is not really full until it contains
sl@0	4360	** usableSize/4 - 2 entries, not usableSize/4 - 8 entries as we have
sl@0	4361	** coded. But due to a coding error in versions of SQLite prior to
sl@0	4362	** 3.6.0, databases with freelist trunk pages holding more than
sl@0	4363	** usableSize/4 - 8 entries will be reported as corrupt. In order
sl@0	4364	** to maintain backwards compatibility with older versions of SQLite,
sl@0	4365	** we will contain to restrict the number of entries to usableSize/4 - 8
sl@0	4366	** for now. At some point in the future (once everyone has upgraded
sl@0	4367	** to 3.6.0 or later) we should consider fixing the conditional above
sl@0	4368	** to read "usableSize/4-2" instead of "usableSize/4-8".
sl@0	4369	*/
sl@0	4370	rc = sqlite3PagerWrite(pPage->pDbPage);
sl@0	4371	if( rc==SQLITE_OK ){
sl@0	4372	put4byte(pPage->aData, pTrunk->pgno);
sl@0	4373	put4byte(&pPage->aData[4], 0);
sl@0	4374	put4byte(&pPage1->aData[32], pPage->pgno);
sl@0	4375	TRACE(("FREE-PAGE: %d new trunk page replacing %d\n",
sl@0	4376	pPage->pgno, pTrunk->pgno));
sl@0	4377	}
sl@0	4378	}else if( k<0 ){
sl@0	4379	rc = SQLITE_CORRUPT;
sl@0	4380	}else{
sl@0	4381	/* Add the newly freed page as a leaf on the current trunk */
sl@0	4382	rc = sqlite3PagerWrite(pTrunk->pDbPage);
sl@0	4383	if( rc==SQLITE_OK ){
sl@0	4384	put4byte(&pTrunk->aData[4], k+1);
sl@0	4385	put4byte(&pTrunk->aData[8+k*4], pPage->pgno);
sl@0	4386	#ifndef SQLITE_SECURE_DELETE
sl@0	4387	rc = sqlite3PagerDontWrite(pPage->pDbPage);
sl@0	4388	#endif
sl@0	4389	}
sl@0	4390	TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
sl@0	4391	}
sl@0	4392	releasePage(pTrunk);
sl@0	4393	}
sl@0	4394	return rc;
sl@0	4395	}
sl@0	4396
sl@0	4397	/*
sl@0	4398	** Free any overflow pages associated with the given Cell.
sl@0	4399	*/
sl@0	4400	static int clearCell(MemPage pPage, unsigned char pCell){
sl@0	4401	BtShared *pBt = pPage->pBt;
sl@0	4402	CellInfo info;
sl@0	4403	Pgno ovflPgno;
sl@0	4404	int rc;
sl@0	4405	int nOvfl;
sl@0	4406	int ovflPageSize;
sl@0	4407
sl@0	4408	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4409	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	4410	if( info.iOverflow==0 ){
sl@0	4411	return SQLITE_OK; /* No overflow pages. Return without doing anything */
sl@0	4412	}
sl@0	4413	ovflPgno = get4byte(&pCell[info.iOverflow]);
sl@0	4414	ovflPageSize = pBt->usableSize - 4;
sl@0	4415	nOvfl = (info.nPayload - info.nLocal + ovflPageSize - 1)/ovflPageSize;
sl@0	4416	assert( ovflPgno==0 \|\| nOvfl>0 );
sl@0	4417	while( nOvfl-- ){
sl@0	4418	MemPage *pOvfl;
sl@0	4419	if( ovflPgno==0 \|\| ovflPgno>pagerPagecount(pBt->pPager) ){
sl@0	4420	return SQLITE_CORRUPT_BKPT;
sl@0	4421	}
sl@0	4422
sl@0	4423	rc = getOverflowPage(pBt, ovflPgno, &pOvfl, (nOvfl==0)?0:&ovflPgno);
sl@0	4424	if( rc ) return rc;
sl@0	4425	rc = freePage(pOvfl);
sl@0	4426	sqlite3PagerUnref(pOvfl->pDbPage);
sl@0	4427	if( rc ) return rc;
sl@0	4428	}
sl@0	4429	return SQLITE_OK;
sl@0	4430	}
sl@0	4431
sl@0	4432	/*
sl@0	4433	** Create the byte sequence used to represent a cell on page pPage
sl@0	4434	** and write that byte sequence into pCell[]. Overflow pages are
sl@0	4435	** allocated and filled in as necessary. The calling procedure
sl@0	4436	** is responsible for making sure sufficient space has been allocated
sl@0	4437	** for pCell[].
sl@0	4438	**
sl@0	4439	** Note that pCell does not necessary need to point to the pPage->aData
sl@0	4440	** area. pCell might point to some temporary storage. The cell will
sl@0	4441	** be constructed in this temporary area then copied into pPage->aData
sl@0	4442	** later.
sl@0	4443	*/
sl@0	4444	static int fillInCell(
sl@0	4445	MemPage pPage, / The page that contains the cell */
sl@0	4446	unsigned char pCell, / Complete text of the cell */
sl@0	4447	const void pKey, i64 nKey, / The key */
sl@0	4448	const void pData,int nData, / The data */
sl@0	4449	int nZero, /* Extra zero bytes to append to pData */
sl@0	4450	int pnSize / Write cell size here */
sl@0	4451	){
sl@0	4452	int nPayload;
sl@0	4453	const u8 *pSrc;
sl@0	4454	int nSrc, n, rc;
sl@0	4455	int spaceLeft;
sl@0	4456	MemPage *pOvfl = 0;
sl@0	4457	MemPage *pToRelease = 0;
sl@0	4458	unsigned char *pPrior;
sl@0	4459	unsigned char *pPayload;
sl@0	4460	BtShared *pBt = pPage->pBt;
sl@0	4461	Pgno pgnoOvfl = 0;
sl@0	4462	int nHeader;
sl@0	4463	CellInfo info;
sl@0	4464
sl@0	4465	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4466
sl@0	4467	/* Fill in the header. */
sl@0	4468	nHeader = 0;
sl@0	4469	if( !pPage->leaf ){
sl@0	4470	nHeader += 4;
sl@0	4471	}
sl@0	4472	if( pPage->hasData ){
sl@0	4473	nHeader += putVarint(&pCell[nHeader], nData+nZero);
sl@0	4474	}else{
sl@0	4475	nData = nZero = 0;
sl@0	4476	}
sl@0	4477	nHeader += putVarint(&pCell[nHeader], (u64)&nKey);
sl@0	4478	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	4479	assert( info.nHeader==nHeader );
sl@0	4480	assert( info.nKey==nKey );
sl@0	4481	assert( info.nData==nData+nZero );
sl@0	4482
sl@0	4483	/* Fill in the payload */
sl@0	4484	nPayload = nData + nZero;
sl@0	4485	if( pPage->intKey ){
sl@0	4486	pSrc = pData;
sl@0	4487	nSrc = nData;
sl@0	4488	nData = 0;
sl@0	4489	}else{
sl@0	4490	nPayload += nKey;
sl@0	4491	pSrc = pKey;
sl@0	4492	nSrc = nKey;
sl@0	4493	}
sl@0	4494	*pnSize = info.nSize;
sl@0	4495	spaceLeft = info.nLocal;
sl@0	4496	pPayload = &pCell[nHeader];
sl@0	4497	pPrior = &pCell[info.iOverflow];
sl@0	4498
sl@0	4499	while( nPayload>0 ){
sl@0	4500	if( spaceLeft==0 ){
sl@0	4501	int isExact = 0;
sl@0	4502	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	4503	Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
sl@0	4504	if( pBt->autoVacuum ){
sl@0	4505	do{
sl@0	4506	pgnoOvfl++;
sl@0	4507	} while(
sl@0	4508	PTRMAP_ISPAGE(pBt, pgnoOvfl) \|\| pgnoOvfl==PENDING_BYTE_PAGE(pBt)
sl@0	4509	);
sl@0	4510	if( pgnoOvfl>1 ){
sl@0	4511	/* isExact = 1; */
sl@0	4512	}
sl@0	4513	}
sl@0	4514	#endif
sl@0	4515	rc = allocateBtreePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, isExact);
sl@0	4516	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	4517	/* If the database supports auto-vacuum, and the second or subsequent
sl@0	4518	** overflow page is being allocated, add an entry to the pointer-map
sl@0	4519	** for that page now.
sl@0	4520	**
sl@0	4521	** If this is the first overflow page, then write a partial entry
sl@0	4522	** to the pointer-map. If we write nothing to this pointer-map slot,
sl@0	4523	** then the optimistic overflow chain processing in clearCell()
sl@0	4524	** may misinterpret the uninitialised values and delete the
sl@0	4525	** wrong pages from the database.
sl@0	4526	*/
sl@0	4527	if( pBt->autoVacuum && rc==SQLITE_OK ){
sl@0	4528	u8 eType = (pgnoPtrmap?PTRMAP_OVERFLOW2:PTRMAP_OVERFLOW1);
sl@0	4529	rc = ptrmapPut(pBt, pgnoOvfl, eType, pgnoPtrmap);
sl@0	4530	if( rc ){
sl@0	4531	releasePage(pOvfl);
sl@0	4532	}
sl@0	4533	}
sl@0	4534	#endif
sl@0	4535	if( rc ){
sl@0	4536	releasePage(pToRelease);
sl@0	4537	return rc;
sl@0	4538	}
sl@0	4539	put4byte(pPrior, pgnoOvfl);
sl@0	4540	releasePage(pToRelease);
sl@0	4541	pToRelease = pOvfl;
sl@0	4542	pPrior = pOvfl->aData;
sl@0	4543	put4byte(pPrior, 0);
sl@0	4544	pPayload = &pOvfl->aData[4];
sl@0	4545	spaceLeft = pBt->usableSize - 4;
sl@0	4546	}
sl@0	4547	n = nPayload;
sl@0	4548	if( n>spaceLeft ) n = spaceLeft;
sl@0	4549	if( nSrc>0 ){
sl@0	4550	if( n>nSrc ) n = nSrc;
sl@0	4551	assert( pSrc );
sl@0	4552	memcpy(pPayload, pSrc, n);
sl@0	4553	}else{
sl@0	4554	memset(pPayload, 0, n);
sl@0	4555	}
sl@0	4556	nPayload -= n;
sl@0	4557	pPayload += n;
sl@0	4558	pSrc += n;
sl@0	4559	nSrc -= n;
sl@0	4560	spaceLeft -= n;
sl@0	4561	if( nSrc==0 ){
sl@0	4562	nSrc = nData;
sl@0	4563	pSrc = pData;
sl@0	4564	}
sl@0	4565	}
sl@0	4566	releasePage(pToRelease);
sl@0	4567	return SQLITE_OK;
sl@0	4568	}
sl@0	4569
sl@0	4570	/*
sl@0	4571	** Remove the i-th cell from pPage. This routine effects pPage only.
sl@0	4572	** The cell content is not freed or deallocated. It is assumed that
sl@0	4573	** the cell content has been copied someplace else. This routine just
sl@0	4574	** removes the reference to the cell from pPage.
sl@0	4575	**
sl@0	4576	** "sz" must be the number of bytes in the cell.
sl@0	4577	*/
sl@0	4578	static int dropCell(MemPage *pPage, int idx, int sz){
sl@0	4579	int i; /* Loop counter */
sl@0	4580	int pc; /* Offset to cell content of cell being deleted */
sl@0	4581	u8 data; / pPage->aData */
sl@0	4582	u8 ptr; / Used to move bytes around within data[] */
sl@0	4583	int rc; /* Return code */
sl@0	4584
sl@0	4585	assert( idx>=0 && idx<pPage->nCell );
sl@0	4586	assert( sz==cellSize(pPage, idx) );
sl@0	4587	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
sl@0	4588	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4589	data = pPage->aData;
sl@0	4590	ptr = &data[pPage->cellOffset + 2*idx];
sl@0	4591	pc = get2byte(ptr);
sl@0	4592	if( pc<pPage->hdrOffset+6+(pPage->leaf?0:4)
sl@0	4593	\|\| pc+sz>pPage->pBt->usableSize
sl@0	4594	){
sl@0	4595	return SQLITE_CORRUPT_BKPT;
sl@0	4596	}
sl@0	4597	rc = freeSpace(pPage, pc, sz);
sl@0	4598	if( rc ) return rc;
sl@0	4599	for(i=idx+1; i<pPage->nCell; i++, ptr+=2){
sl@0	4600	ptr[0] = ptr[2];
sl@0	4601	ptr[1] = ptr[3];
sl@0	4602	}
sl@0	4603	pPage->nCell--;
sl@0	4604	put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
sl@0	4605	pPage->nFree += 2;
sl@0	4606	return SQLITE_OK;
sl@0	4607	}
sl@0	4608
sl@0	4609	/*
sl@0	4610	** Insert a new cell on pPage at cell index "i". pCell points to the
sl@0	4611	** content of the cell.
sl@0	4612	**
sl@0	4613	** If the cell content will fit on the page, then put it there. If it
sl@0	4614	** will not fit, then make a copy of the cell content into pTemp if
sl@0	4615	** pTemp is not null. Regardless of pTemp, allocate a new entry
sl@0	4616	** in pPage->aOvfl[] and make it point to the cell content (either
sl@0	4617	** in pTemp or the original pCell) and also record its index.
sl@0	4618	** Allocating a new entry in pPage->aCell[] implies that
sl@0	4619	** pPage->nOverflow is incremented.
sl@0	4620	**
sl@0	4621	** If nSkip is non-zero, then do not copy the first nSkip bytes of the
sl@0	4622	** cell. The caller will overwrite them after this function returns. If
sl@0	4623	** nSkip is non-zero, then pCell may not point to an invalid memory location
sl@0	4624	** (but pCell+nSkip is always valid).
sl@0	4625	*/
sl@0	4626	static int insertCell(
sl@0	4627	MemPage pPage, / Page into which we are copying */
sl@0	4628	int i, /* New cell becomes the i-th cell of the page */
sl@0	4629	u8 pCell, / Content of the new cell */
sl@0	4630	int sz, /* Bytes of content in pCell */
sl@0	4631	u8 pTemp, / Temp storage space for pCell, if needed */
sl@0	4632	u8 nSkip /* Do not write the first nSkip bytes of the cell */
sl@0	4633	){
sl@0	4634	int idx; /* Where to write new cell content in data[] */
sl@0	4635	int j; /* Loop counter */
sl@0	4636	int top; /* First byte of content for any cell in data[] */
sl@0	4637	int end; /* First byte past the last cell pointer in data[] */
sl@0	4638	int ins; /* Index in data[] where new cell pointer is inserted */
sl@0	4639	int hdr; /* Offset into data[] of the page header */
sl@0	4640	int cellOffset; /* Address of first cell pointer in data[] */
sl@0	4641	u8 data; / The content of the whole page */
sl@0	4642	u8 ptr; / Used for moving information around in data[] */
sl@0	4643
sl@0	4644	assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
sl@0	4645	assert( sz==cellSizePtr(pPage, pCell) );
sl@0	4646	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4647	if( pPage->nOverflow \|\| sz+2>pPage->nFree ){
sl@0	4648	if( pTemp ){
sl@0	4649	memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
sl@0	4650	pCell = pTemp;
sl@0	4651	}
sl@0	4652	j = pPage->nOverflow++;
sl@0	4653	assert( j<sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0]) );
sl@0	4654	pPage->aOvfl[j].pCell = pCell;
sl@0	4655	pPage->aOvfl[j].idx = i;
sl@0	4656	pPage->nFree = 0;
sl@0	4657	}else{
sl@0	4658	int rc = sqlite3PagerWrite(pPage->pDbPage);
sl@0	4659	if( rc!=SQLITE_OK ){
sl@0	4660	return rc;
sl@0	4661	}
sl@0	4662	assert( sqlite3PagerIswriteable(pPage->pDbPage) );
sl@0	4663	data = pPage->aData;
sl@0	4664	hdr = pPage->hdrOffset;
sl@0	4665	top = get2byte(&data[hdr+5]);
sl@0	4666	cellOffset = pPage->cellOffset;
sl@0	4667	end = cellOffset + 2*pPage->nCell + 2;
sl@0	4668	ins = cellOffset + 2*i;
sl@0	4669	if( end > top - sz ){
sl@0	4670	rc = defragmentPage(pPage);
sl@0	4671	if( rc ) return rc;
sl@0	4672	top = get2byte(&data[hdr+5]);
sl@0	4673	assert( end + sz <= top );
sl@0	4674	}
sl@0	4675	idx = allocateSpace(pPage, sz);
sl@0	4676	assert( idx>0 );
sl@0	4677	assert( end <= get2byte(&data[hdr+5]) );
sl@0	4678	if( idx+sz > pPage->pBt->usableSize ){
sl@0	4679	return SQLITE_CORRUPT_BKPT;
sl@0	4680	}
sl@0	4681	pPage->nCell++;
sl@0	4682	pPage->nFree -= 2;
sl@0	4683	memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
sl@0	4684	for(j=end-2, ptr=&data[j]; j>ins; j-=2, ptr-=2){
sl@0	4685	ptr[0] = ptr[-2];
sl@0	4686	ptr[1] = ptr[-1];
sl@0	4687	}
sl@0	4688	put2byte(&data[ins], idx);
sl@0	4689	put2byte(&data[hdr+3], pPage->nCell);
sl@0	4690	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	4691	if( pPage->pBt->autoVacuum ){
sl@0	4692	/* The cell may contain a pointer to an overflow page. If so, write
sl@0	4693	** the entry for the overflow page into the pointer map.
sl@0	4694	*/
sl@0	4695	CellInfo info;
sl@0	4696	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	4697	assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
sl@0	4698	if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){
sl@0	4699	Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
sl@0	4700	rc = ptrmapPut(pPage->pBt, pgnoOvfl, PTRMAP_OVERFLOW1, pPage->pgno);
sl@0	4701	if( rc!=SQLITE_OK ) return rc;
sl@0	4702	}
sl@0	4703	}
sl@0	4704	#endif
sl@0	4705	}
sl@0	4706
sl@0	4707	return SQLITE_OK;
sl@0	4708	}
sl@0	4709
sl@0	4710	/*
sl@0	4711	** Add a list of cells to a page. The page should be initially empty.
sl@0	4712	** The cells are guaranteed to fit on the page.
sl@0	4713	*/
sl@0	4714	static void assemblePage(
sl@0	4715	MemPage pPage, / The page to be assemblied */
sl@0	4716	int nCell, /* The number of cells to add to this page */
sl@0	4717	u8 *apCell, / Pointers to cell bodies */
sl@0	4718	u16 aSize / Sizes of the cells */
sl@0	4719	){
sl@0	4720	int i; /* Loop counter */
sl@0	4721	int totalSize; /* Total size of all cells */
sl@0	4722	int hdr; /* Index of page header */
sl@0	4723	int cellptr; /* Address of next cell pointer */
sl@0	4724	int cellbody; /* Address of next cell body */
sl@0	4725	u8 data; / Data for the page */
sl@0	4726
sl@0	4727	assert( pPage->nOverflow==0 );
sl@0	4728	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4729	totalSize = 0;
sl@0	4730	for(i=0; i<nCell; i++){
sl@0	4731	totalSize += aSize[i];
sl@0	4732	}
sl@0	4733	assert( totalSize+2*nCell<=pPage->nFree );
sl@0	4734	assert( pPage->nCell==0 );
sl@0	4735	cellptr = pPage->cellOffset;
sl@0	4736	data = pPage->aData;
sl@0	4737	hdr = pPage->hdrOffset;
sl@0	4738	put2byte(&data[hdr+3], nCell);
sl@0	4739	if( nCell ){
sl@0	4740	cellbody = allocateSpace(pPage, totalSize);
sl@0	4741	assert( cellbody>0 );
sl@0	4742	assert( pPage->nFree >= 2*nCell );
sl@0	4743	pPage->nFree -= 2*nCell;
sl@0	4744	for(i=0; i<nCell; i++){
sl@0	4745	put2byte(&data[cellptr], cellbody);
sl@0	4746	memcpy(&data[cellbody], apCell[i], aSize[i]);
sl@0	4747	cellptr += 2;
sl@0	4748	cellbody += aSize[i];
sl@0	4749	}
sl@0	4750	assert( cellbody==pPage->pBt->usableSize );
sl@0	4751	}
sl@0	4752	pPage->nCell = nCell;
sl@0	4753	}
sl@0	4754
sl@0	4755	/*
sl@0	4756	** The following parameters determine how many adjacent pages get involved
sl@0	4757	** in a balancing operation. NN is the number of neighbors on either side
sl@0	4758	** of the page that participate in the balancing operation. NB is the
sl@0	4759	** total number of pages that participate, including the target page and
sl@0	4760	** NN neighbors on either side.
sl@0	4761	**
sl@0	4762	** The minimum value of NN is 1 (of course). Increasing NN above 1
sl@0	4763	** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
sl@0	4764	** in exchange for a larger degradation in INSERT and UPDATE performance.
sl@0	4765	** The value of NN appears to give the best results overall.
sl@0	4766	*/
sl@0	4767	#define NN 1 /* Number of neighbors on either side of pPage */
sl@0	4768	#define NB (NN2+1) / Total pages involved in the balance */
sl@0	4769
sl@0	4770	/* Forward reference */
sl@0	4771	static int balance(BtCursor*, int);
sl@0	4772
sl@0	4773	#ifndef SQLITE_OMIT_QUICKBALANCE
sl@0	4774	/*
sl@0	4775	** This version of balance() handles the common special case where
sl@0	4776	** a new entry is being inserted on the extreme right-end of the
sl@0	4777	** tree, in other words, when the new entry will become the largest
sl@0	4778	** entry in the tree.
sl@0	4779	**
sl@0	4780	** Instead of trying balance the 3 right-most leaf pages, just add
sl@0	4781	** a new page to the right-hand side and put the one new entry in
sl@0	4782	** that page. This leaves the right side of the tree somewhat
sl@0	4783	** unbalanced. But odds are that we will be inserting new entries
sl@0	4784	** at the end soon afterwards so the nearly empty page will quickly
sl@0	4785	** fill up. On average.
sl@0	4786	**
sl@0	4787	** pPage is the leaf page which is the right-most page in the tree.
sl@0	4788	** pParent is its parent. pPage must have a single overflow entry
sl@0	4789	** which is also the right-most entry on the page.
sl@0	4790	*/
sl@0	4791	static int balance_quick(BtCursor *pCur){
sl@0	4792	int rc;
sl@0	4793	MemPage *pNew = 0;
sl@0	4794	Pgno pgnoNew;
sl@0	4795	u8 *pCell;
sl@0	4796	u16 szCell;
sl@0	4797	CellInfo info;
sl@0	4798	MemPage *pPage = pCur->apPage[pCur->iPage];
sl@0	4799	MemPage *pParent = pCur->apPage[pCur->iPage-1];
sl@0	4800	BtShared *pBt = pPage->pBt;
sl@0	4801	int parentIdx = pParent->nCell; /* pParent new divider cell index */
sl@0	4802	int parentSize; /* Size of new divider cell */
sl@0	4803	u8 parentCell[64]; /* Space for the new divider cell */
sl@0	4804
sl@0	4805	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4806
sl@0	4807	/* Allocate a new page. Insert the overflow cell from pPage
sl@0	4808	** into it. Then remove the overflow cell from pPage.
sl@0	4809	*/
sl@0	4810	rc = allocateBtreePage(pBt, &pNew, &pgnoNew, 0, 0);
sl@0	4811	if( rc==SQLITE_OK ){
sl@0	4812	pCell = pPage->aOvfl[0].pCell;
sl@0	4813	szCell = cellSizePtr(pPage, pCell);
sl@0	4814	zeroPage(pNew, pPage->aData[0]);
sl@0	4815	assemblePage(pNew, 1, &pCell, &szCell);
sl@0	4816	pPage->nOverflow = 0;
sl@0	4817
sl@0	4818	/* pPage is currently the right-child of pParent. Change this
sl@0	4819	** so that the right-child is the new page allocated above and
sl@0	4820	** pPage is the next-to-right child.
sl@0	4821	**
sl@0	4822	** Ignore the return value of the call to fillInCell(). fillInCell()
sl@0	4823	** may only return other than SQLITE_OK if it is required to allocate
sl@0	4824	** one or more overflow pages. Since an internal table B-Tree cell
sl@0	4825	** may never spill over onto an overflow page (it is a maximum of
sl@0	4826	** 13 bytes in size), it is not neccessary to check the return code.
sl@0	4827	**
sl@0	4828	** Similarly, the insertCell() function cannot fail if the page
sl@0	4829	** being inserted into is already writable and the cell does not
sl@0	4830	** contain an overflow pointer. So ignore this return code too.
sl@0	4831	*/
sl@0	4832	assert( pPage->nCell>0 );
sl@0	4833	pCell = findCell(pPage, pPage->nCell-1);
sl@0	4834	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	4835	fillInCell(pParent, parentCell, 0, info.nKey, 0, 0, 0, &parentSize);
sl@0	4836	assert( parentSize<64 );
sl@0	4837	assert( sqlite3PagerIswriteable(pParent->pDbPage) );
sl@0	4838	insertCell(pParent, parentIdx, parentCell, parentSize, 0, 4);
sl@0	4839	put4byte(findOverflowCell(pParent,parentIdx), pPage->pgno);
sl@0	4840	put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
sl@0	4841
sl@0	4842	/* If this is an auto-vacuum database, update the pointer map
sl@0	4843	** with entries for the new page, and any pointer from the
sl@0	4844	** cell on the page to an overflow page.
sl@0	4845	*/
sl@0	4846	if( ISAUTOVACUUM ){
sl@0	4847	rc = ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno);
sl@0	4848	if( rc==SQLITE_OK ){
sl@0	4849	rc = ptrmapPutOvfl(pNew, 0);
sl@0	4850	}
sl@0	4851	}
sl@0	4852
sl@0	4853	/* Release the reference to the new page. */
sl@0	4854	releasePage(pNew);
sl@0	4855	}
sl@0	4856
sl@0	4857	/* At this point the pPage->nFree variable is not set correctly with
sl@0	4858	** respect to the content of the page (because it was set to 0 by
sl@0	4859	** insertCell). So call sqlite3BtreeInitPage() to make sure it is
sl@0	4860	** correct.
sl@0	4861	**
sl@0	4862	** This has to be done even if an error will be returned. Normally, if
sl@0	4863	** an error occurs during tree balancing, the contents of MemPage are
sl@0	4864	** not important, as they will be recalculated when the page is rolled
sl@0	4865	** back. But here, in balance_quick(), it is possible that pPage has
sl@0	4866	** not yet been marked dirty or written into the journal file. Therefore
sl@0	4867	** it will not be rolled back and so it is important to make sure that
sl@0	4868	** the page data and contents of MemPage are consistent.
sl@0	4869	*/
sl@0	4870	pPage->isInit = 0;
sl@0	4871	sqlite3BtreeInitPage(pPage);
sl@0	4872
sl@0	4873	/* If everything else succeeded, balance the parent page, in
sl@0	4874	** case the divider cell inserted caused it to become overfull.
sl@0	4875	*/
sl@0	4876	if( rc==SQLITE_OK ){
sl@0	4877	releasePage(pPage);
sl@0	4878	pCur->iPage--;
sl@0	4879	rc = balance(pCur, 0);
sl@0	4880	}
sl@0	4881	return rc;
sl@0	4882	}
sl@0	4883	#endif /* SQLITE_OMIT_QUICKBALANCE */
sl@0	4884
sl@0	4885	/*
sl@0	4886	** This routine redistributes Cells on pPage and up to NN*2 siblings
sl@0	4887	** of pPage so that all pages have about the same amount of free space.
sl@0	4888	** Usually NN siblings on either side of pPage is used in the balancing,
sl@0	4889	** though more siblings might come from one side if pPage is the first
sl@0	4890	** or last child of its parent. If pPage has fewer than 2*NN siblings
sl@0	4891	** (something which can only happen if pPage is the root page or a
sl@0	4892	** child of root) then all available siblings participate in the balancing.
sl@0	4893	**
sl@0	4894	** The number of siblings of pPage might be increased or decreased by one or
sl@0	4895	** two in an effort to keep pages nearly full but not over full. The root page
sl@0	4896	** is special and is allowed to be nearly empty. If pPage is
sl@0	4897	** the root page, then the depth of the tree might be increased
sl@0	4898	** or decreased by one, as necessary, to keep the root page from being
sl@0	4899	** overfull or completely empty.
sl@0	4900	**
sl@0	4901	** Note that when this routine is called, some of the Cells on pPage
sl@0	4902	** might not actually be stored in pPage->aData[]. This can happen
sl@0	4903	** if the page is overfull. Part of the job of this routine is to
sl@0	4904	** make sure all Cells for pPage once again fit in pPage->aData[].
sl@0	4905	**
sl@0	4906	** In the course of balancing the siblings of pPage, the parent of pPage
sl@0	4907	** might become overfull or underfull. If that happens, then this routine
sl@0	4908	** is called recursively on the parent.
sl@0	4909	**
sl@0	4910	** If this routine fails for any reason, it might leave the database
sl@0	4911	** in a corrupted state. So if this routine fails, the database should
sl@0	4912	** be rolled back.
sl@0	4913	*/
sl@0	4914	static int balance_nonroot(BtCursor *pCur){
sl@0	4915	MemPage pPage; / The over or underfull page to balance */
sl@0	4916	MemPage pParent; / The parent of pPage */
sl@0	4917	BtShared pBt; / The whole database */
sl@0	4918	int nCell = 0; /* Number of cells in apCell[] */
sl@0	4919	int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */
sl@0	4920	int nOld; /* Number of pages in apOld[] */
sl@0	4921	int nNew; /* Number of pages in apNew[] */
sl@0	4922	int nDiv; /* Number of cells in apDiv[] */
sl@0	4923	int i, j, k; /* Loop counters */
sl@0	4924	int idx; /* Index of pPage in pParent->aCell[] */
sl@0	4925	int nxDiv; /* Next divider slot in pParent->aCell[] */
sl@0	4926	int rc; /* The return code */
sl@0	4927	int leafCorrection; /* 4 if pPage is a leaf. 0 if not */
sl@0	4928	int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
sl@0	4929	int usableSpace; /* Bytes in pPage beyond the header */
sl@0	4930	int pageFlags; /* Value of pPage->aData[0] */
sl@0	4931	int subtotal; /* Subtotal of bytes in cells on one page */
sl@0	4932	int iSpace1 = 0; /* First unused byte of aSpace1[] */
sl@0	4933	int iSpace2 = 0; /* First unused byte of aSpace2[] */
sl@0	4934	int szScratch; /* Size of scratch memory requested */
sl@0	4935	MemPage apOld[NB]; / pPage and up to two siblings */
sl@0	4936	Pgno pgnoOld[NB]; /* Page numbers for each page in apOld[] */
sl@0	4937	MemPage apCopy[NB]; / Private copies of apOld[] pages */
sl@0	4938	MemPage apNew[NB+2]; / pPage and up to NB siblings after balancing */
sl@0	4939	Pgno pgnoNew[NB+2]; /* Page numbers for each page in apNew[] */
sl@0	4940	u8 apDiv[NB]; / Divider cells in pParent */
sl@0	4941	int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */
sl@0	4942	int szNew[NB+2]; /* Combined size of cells place on i-th page */
sl@0	4943	u8 *apCell = 0; / All cells begin balanced */
sl@0	4944	u16 szCell; / Local size of all cells in apCell[] */
sl@0	4945	u8 aCopy[NB]; / Space for holding data of apCopy[] */
sl@0	4946	u8 aSpace1; / Space for copies of dividers cells before balance */
sl@0	4947	u8 aSpace2 = 0; / Space for overflow dividers cells after balance */
sl@0	4948	u8 *aFrom = 0;
sl@0	4949
sl@0	4950	pPage = pCur->apPage[pCur->iPage];
sl@0	4951	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	4952	VVA_ONLY( pCur->pagesShuffled = 1 );
sl@0	4953
sl@0	4954	/*
sl@0	4955	** Find the parent page.
sl@0	4956	*/
sl@0	4957	assert( pCur->iPage>0 );
sl@0	4958	assert( pPage->isInit );
sl@0	4959	assert( sqlite3PagerIswriteable(pPage->pDbPage) \|\| pPage->nOverflow==1 );
sl@0	4960	pBt = pPage->pBt;
sl@0	4961	pParent = pCur->apPage[pCur->iPage-1];
sl@0	4962	assert( pParent );
sl@0	4963	if( SQLITE_OK!=(rc = sqlite3PagerWrite(pParent->pDbPage)) ){
sl@0	4964	return rc;
sl@0	4965	}
sl@0	4966
sl@0	4967	TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
sl@0	4968
sl@0	4969	#ifndef SQLITE_OMIT_QUICKBALANCE
sl@0	4970	/*
sl@0	4971	** A special case: If a new entry has just been inserted into a
sl@0	4972	** table (that is, a btree with integer keys and all data at the leaves)
sl@0	4973	** and the new entry is the right-most entry in the tree (it has the
sl@0	4974	** largest key) then use the special balance_quick() routine for
sl@0	4975	** balancing. balance_quick() is much faster and results in a tighter
sl@0	4976	** packing of data in the common case.
sl@0	4977	*/
sl@0	4978	if( pPage->leaf &&
sl@0	4979	pPage->intKey &&
sl@0	4980	pPage->nOverflow==1 &&
sl@0	4981	pPage->aOvfl[0].idx==pPage->nCell &&
sl@0	4982	pParent->pgno!=1 &&
sl@0	4983	get4byte(&pParent->aData[pParent->hdrOffset+8])==pPage->pgno
sl@0	4984	){
sl@0	4985	assert( pPage->intKey );
sl@0	4986	/*
sl@0	4987	** TODO: Check the siblings to the left of pPage. It may be that
sl@0	4988	** they are not full and no new page is required.
sl@0	4989	*/
sl@0	4990	return balance_quick(pCur);
sl@0	4991	}
sl@0	4992	#endif
sl@0	4993
sl@0	4994	if( SQLITE_OK!=(rc = sqlite3PagerWrite(pPage->pDbPage)) ){
sl@0	4995	return rc;
sl@0	4996	}
sl@0	4997
sl@0	4998	/*
sl@0	4999	** Find the cell in the parent page whose left child points back
sl@0	5000	** to pPage. The "idx" variable is the index of that cell. If pPage
sl@0	5001	** is the rightmost child of pParent then set idx to pParent->nCell
sl@0	5002	*/
sl@0	5003	idx = pCur->aiIdx[pCur->iPage-1];
sl@0	5004	assertParentIndex(pParent, idx, pPage->pgno);
sl@0	5005
sl@0	5006	/*
sl@0	5007	** Initialize variables so that it will be safe to jump
sl@0	5008	** directly to balance_cleanup at any moment.
sl@0	5009	*/
sl@0	5010	nOld = nNew = 0;
sl@0	5011
sl@0	5012	/*
sl@0	5013	** Find sibling pages to pPage and the cells in pParent that divide
sl@0	5014	** the siblings. An attempt is made to find NN siblings on either
sl@0	5015	** side of pPage. More siblings are taken from one side, however, if
sl@0	5016	** pPage there are fewer than NN siblings on the other side. If pParent
sl@0	5017	** has NB or fewer children then all children of pParent are taken.
sl@0	5018	*/
sl@0	5019	nxDiv = idx - NN;
sl@0	5020	if( nxDiv + NB > pParent->nCell ){
sl@0	5021	nxDiv = pParent->nCell - NB + 1;
sl@0	5022	}
sl@0	5023	if( nxDiv<0 ){
sl@0	5024	nxDiv = 0;
sl@0	5025	}
sl@0	5026	nDiv = 0;
sl@0	5027	for(i=0, k=nxDiv; i<NB; i++, k++){
sl@0	5028	if( k<pParent->nCell ){
sl@0	5029	apDiv[i] = findCell(pParent, k);
sl@0	5030	nDiv++;
sl@0	5031	assert( !pParent->leaf );
sl@0	5032	pgnoOld[i] = get4byte(apDiv[i]);
sl@0	5033	}else if( k==pParent->nCell ){
sl@0	5034	pgnoOld[i] = get4byte(&pParent->aData[pParent->hdrOffset+8]);
sl@0	5035	}else{
sl@0	5036	break;
sl@0	5037	}
sl@0	5038	rc = getAndInitPage(pBt, pgnoOld[i], &apOld[i]);
sl@0	5039	if( rc ) goto balance_cleanup;
sl@0	5040	/* apOld[i]->idxParent = k; */
sl@0	5041	apCopy[i] = 0;
sl@0	5042	assert( i==nOld );
sl@0	5043	nOld++;
sl@0	5044	nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
sl@0	5045	}
sl@0	5046
sl@0	5047	/* Make nMaxCells a multiple of 4 in order to preserve 8-byte
sl@0	5048	** alignment */
sl@0	5049	nMaxCells = (nMaxCells + 3)&~3;
sl@0	5050
sl@0	5051	/*
sl@0	5052	** Allocate space for memory structures
sl@0	5053	*/
sl@0	5054	szScratch =
sl@0	5055	nMaxCellssizeof(u8) /* apCell */
sl@0	5056	+ nMaxCellssizeof(u16) / szCell */
sl@0	5057	+ (ROUND8(sizeof(MemPage))+pBt->pageSize)NB / aCopy */
sl@0	5058	+ pBt->pageSize /* aSpace1 */
sl@0	5059	+ (ISAUTOVACUUM ? nMaxCells : 0); /* aFrom */
sl@0	5060	apCell = sqlite3ScratchMalloc( szScratch );
sl@0	5061	if( apCell==0 ){
sl@0	5062	rc = SQLITE_NOMEM;
sl@0	5063	goto balance_cleanup;
sl@0	5064	}
sl@0	5065	szCell = (u16*)&apCell[nMaxCells];
sl@0	5066	aCopy[0] = (u8*)&szCell[nMaxCells];
sl@0	5067	assert( ((aCopy[0] - (u8)apCell) & 7)==0 ); / 8-byte alignment required */
sl@0	5068	for(i=1; i<NB; i++){
sl@0	5069	aCopy[i] = &aCopy[i-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
sl@0	5070	assert( ((aCopy[i] - (u8)apCell) & 7)==0 ); / 8-byte alignment required */
sl@0	5071	}
sl@0	5072	aSpace1 = &aCopy[NB-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
sl@0	5073	assert( ((aSpace1 - (u8)apCell) & 7)==0 ); / 8-byte alignment required */
sl@0	5074	if( ISAUTOVACUUM ){
sl@0	5075	aFrom = &aSpace1[pBt->pageSize];
sl@0	5076	}
sl@0	5077	aSpace2 = sqlite3PageMalloc(pBt->pageSize);
sl@0	5078	if( aSpace2==0 ){
sl@0	5079	rc = SQLITE_NOMEM;
sl@0	5080	goto balance_cleanup;
sl@0	5081	}
sl@0	5082
sl@0	5083	/*
sl@0	5084	** Make copies of the content of pPage and its siblings into aOld[].
sl@0	5085	** The rest of this function will use data from the copies rather
sl@0	5086	** that the original pages since the original pages will be in the
sl@0	5087	** process of being overwritten.
sl@0	5088	*/
sl@0	5089	for(i=0; i<nOld; i++){
sl@0	5090	MemPage p = apCopy[i] = (MemPage)aCopy[i];
sl@0	5091	memcpy(p, apOld[i], sizeof(MemPage));
sl@0	5092	p->aData = (void*)&p[1];
sl@0	5093	memcpy(p->aData, apOld[i]->aData, pBt->pageSize);
sl@0	5094	}
sl@0	5095
sl@0	5096	/*
sl@0	5097	** Load pointers to all cells on sibling pages and the divider cells
sl@0	5098	** into the local apCell[] array. Make copies of the divider cells
sl@0	5099	** into space obtained form aSpace1[] and remove the the divider Cells
sl@0	5100	** from pParent.
sl@0	5101	**
sl@0	5102	** If the siblings are on leaf pages, then the child pointers of the
sl@0	5103	** divider cells are stripped from the cells before they are copied
sl@0	5104	** into aSpace1[]. In this way, all cells in apCell[] are without
sl@0	5105	** child pointers. If siblings are not leaves, then all cell in
sl@0	5106	** apCell[] include child pointers. Either way, all cells in apCell[]
sl@0	5107	** are alike.
sl@0	5108	**
sl@0	5109	** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
sl@0	5110	** leafData: 1 if pPage holds key+data and pParent holds only keys.
sl@0	5111	*/
sl@0	5112	nCell = 0;
sl@0	5113	leafCorrection = pPage->leaf*4;
sl@0	5114	leafData = pPage->hasData;
sl@0	5115	for(i=0; i<nOld; i++){
sl@0	5116	MemPage *pOld = apCopy[i];
sl@0	5117	int limit = pOld->nCell+pOld->nOverflow;
sl@0	5118	for(j=0; j<limit; j++){
sl@0	5119	assert( nCell<nMaxCells );
sl@0	5120	apCell[nCell] = findOverflowCell(pOld, j);
sl@0	5121	szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
sl@0	5122	if( ISAUTOVACUUM ){
sl@0	5123	int a;
sl@0	5124	aFrom[nCell] = i;
sl@0	5125	for(a=0; a<pOld->nOverflow; a++){
sl@0	5126	if( pOld->aOvfl[a].pCell==apCell[nCell] ){
sl@0	5127	aFrom[nCell] = 0xFF;
sl@0	5128	break;
sl@0	5129	}
sl@0	5130	}
sl@0	5131	}
sl@0	5132	nCell++;
sl@0	5133	}
sl@0	5134	if( i<nOld-1 ){
sl@0	5135	u16 sz = cellSizePtr(pParent, apDiv[i]);
sl@0	5136	if( leafData ){
sl@0	5137	/* With the LEAFDATA flag, pParent cells hold only INTKEYs that
sl@0	5138	** are duplicates of keys on the child pages. We need to remove
sl@0	5139	** the divider cells from pParent, but the dividers cells are not
sl@0	5140	** added to apCell[] because they are duplicates of child cells.
sl@0	5141	*/
sl@0	5142	dropCell(pParent, nxDiv, sz);
sl@0	5143	}else{
sl@0	5144	u8 *pTemp;
sl@0	5145	assert( nCell<nMaxCells );
sl@0	5146	szCell[nCell] = sz;
sl@0	5147	pTemp = &aSpace1[iSpace1];
sl@0	5148	iSpace1 += sz;
sl@0	5149	assert( sz<=pBt->pageSize/4 );
sl@0	5150	assert( iSpace1<=pBt->pageSize );
sl@0	5151	memcpy(pTemp, apDiv[i], sz);
sl@0	5152	apCell[nCell] = pTemp+leafCorrection;
sl@0	5153	if( ISAUTOVACUUM ){
sl@0	5154	aFrom[nCell] = 0xFF;
sl@0	5155	}
sl@0	5156	dropCell(pParent, nxDiv, sz);
sl@0	5157	szCell[nCell] -= leafCorrection;
sl@0	5158	assert( get4byte(pTemp)==pgnoOld[i] );
sl@0	5159	if( !pOld->leaf ){
sl@0	5160	assert( leafCorrection==0 );
sl@0	5161	/* The right pointer of the child page pOld becomes the left
sl@0	5162	** pointer of the divider cell */
sl@0	5163	memcpy(apCell[nCell], &pOld->aData[pOld->hdrOffset+8], 4);
sl@0	5164	}else{
sl@0	5165	assert( leafCorrection==4 );
sl@0	5166	if( szCell[nCell]<4 ){
sl@0	5167	/* Do not allow any cells smaller than 4 bytes. */
sl@0	5168	szCell[nCell] = 4;
sl@0	5169	}
sl@0	5170	}
sl@0	5171	nCell++;
sl@0	5172	}
sl@0	5173	}
sl@0	5174	}
sl@0	5175
sl@0	5176	/*
sl@0	5177	** Figure out the number of pages needed to hold all nCell cells.
sl@0	5178	** Store this number in "k". Also compute szNew[] which is the total
sl@0	5179	** size of all cells on the i-th page and cntNew[] which is the index
sl@0	5180	** in apCell[] of the cell that divides page i from page i+1.
sl@0	5181	** cntNew[k] should equal nCell.
sl@0	5182	**
sl@0	5183	** Values computed by this block:
sl@0	5184	**
sl@0	5185	** k: The total number of sibling pages
sl@0	5186	** szNew[i]: Spaced used on the i-th sibling page.
sl@0	5187	** cntNew[i]: Index in apCell[] and szCell[] for the first cell to
sl@0	5188	** the right of the i-th sibling page.
sl@0	5189	** usableSpace: Number of bytes of space available on each sibling.
sl@0	5190	**
sl@0	5191	*/
sl@0	5192	usableSpace = pBt->usableSize - 12 + leafCorrection;
sl@0	5193	for(subtotal=k=i=0; i<nCell; i++){
sl@0	5194	assert( i<nMaxCells );
sl@0	5195	subtotal += szCell[i] + 2;
sl@0	5196	if( subtotal > usableSpace ){
sl@0	5197	szNew[k] = subtotal - szCell[i];
sl@0	5198	cntNew[k] = i;
sl@0	5199	if( leafData ){ i--; }
sl@0	5200	subtotal = 0;
sl@0	5201	k++;
sl@0	5202	}
sl@0	5203	}
sl@0	5204	szNew[k] = subtotal;
sl@0	5205	cntNew[k] = nCell;
sl@0	5206	k++;
sl@0	5207
sl@0	5208	/*
sl@0	5209	** The packing computed by the previous block is biased toward the siblings
sl@0	5210	** on the left side. The left siblings are always nearly full, while the
sl@0	5211	** right-most sibling might be nearly empty. This block of code attempts
sl@0	5212	** to adjust the packing of siblings to get a better balance.
sl@0	5213	**
sl@0	5214	** This adjustment is more than an optimization. The packing above might
sl@0	5215	** be so out of balance as to be illegal. For example, the right-most
sl@0	5216	** sibling might be completely empty. This adjustment is not optional.
sl@0	5217	*/
sl@0	5218	for(i=k-1; i>0; i--){
sl@0	5219	int szRight = szNew[i]; /* Size of sibling on the right */
sl@0	5220	int szLeft = szNew[i-1]; /* Size of sibling on the left */
sl@0	5221	int r; /* Index of right-most cell in left sibling */
sl@0	5222	int d; /* Index of first cell to the left of right sibling */
sl@0	5223
sl@0	5224	r = cntNew[i-1] - 1;
sl@0	5225	d = r + 1 - leafData;
sl@0	5226	assert( d<nMaxCells );
sl@0	5227	assert( r<nMaxCells );
sl@0	5228	while( szRight==0 \|\| szRight+szCell[d]+2<=szLeft-(szCell[r]+2) ){
sl@0	5229	szRight += szCell[d] + 2;
sl@0	5230	szLeft -= szCell[r] + 2;
sl@0	5231	cntNew[i-1]--;
sl@0	5232	r = cntNew[i-1] - 1;
sl@0	5233	d = r + 1 - leafData;
sl@0	5234	}
sl@0	5235	szNew[i] = szRight;
sl@0	5236	szNew[i-1] = szLeft;
sl@0	5237	}
sl@0	5238
sl@0	5239	/* Either we found one or more cells (cntnew[0])>0) or we are the
sl@0	5240	** a virtual root page. A virtual root page is when the real root
sl@0	5241	** page is page 1 and we are the only child of that page.
sl@0	5242	*/
sl@0	5243	assert( cntNew[0]>0 \|\| (pParent->pgno==1 && pParent->nCell==0) );
sl@0	5244
sl@0	5245	/*
sl@0	5246	** Allocate k new pages. Reuse old pages where possible.
sl@0	5247	*/
sl@0	5248	assert( pPage->pgno>1 );
sl@0	5249	pageFlags = pPage->aData[0];
sl@0	5250	for(i=0; i<k; i++){
sl@0	5251	MemPage *pNew;
sl@0	5252	if( i<nOld ){
sl@0	5253	pNew = apNew[i] = apOld[i];
sl@0	5254	pgnoNew[i] = pgnoOld[i];
sl@0	5255	apOld[i] = 0;
sl@0	5256	rc = sqlite3PagerWrite(pNew->pDbPage);
sl@0	5257	nNew++;
sl@0	5258	if( rc ) goto balance_cleanup;
sl@0	5259	}else{
sl@0	5260	assert( i>0 );
sl@0	5261	rc = allocateBtreePage(pBt, &pNew, &pgnoNew[i], pgnoNew[i-1], 0);
sl@0	5262	if( rc ) goto balance_cleanup;
sl@0	5263	apNew[i] = pNew;
sl@0	5264	nNew++;
sl@0	5265	}
sl@0	5266	}
sl@0	5267
sl@0	5268	/* Free any old pages that were not reused as new pages.
sl@0	5269	*/
sl@0	5270	while( i<nOld ){
sl@0	5271	rc = freePage(apOld[i]);
sl@0	5272	if( rc ) goto balance_cleanup;
sl@0	5273	releasePage(apOld[i]);
sl@0	5274	apOld[i] = 0;
sl@0	5275	i++;
sl@0	5276	}
sl@0	5277
sl@0	5278	/*
sl@0	5279	** Put the new pages in accending order. This helps to
sl@0	5280	** keep entries in the disk file in order so that a scan
sl@0	5281	** of the table is a linear scan through the file. That
sl@0	5282	** in turn helps the operating system to deliver pages
sl@0	5283	** from the disk more rapidly.
sl@0	5284	**
sl@0	5285	** An O(n^2) insertion sort algorithm is used, but since
sl@0	5286	** n is never more than NB (a small constant), that should
sl@0	5287	** not be a problem.
sl@0	5288	**
sl@0	5289	** When NB==3, this one optimization makes the database
sl@0	5290	** about 25% faster for large insertions and deletions.
sl@0	5291	*/
sl@0	5292	for(i=0; i<k-1; i++){
sl@0	5293	int minV = pgnoNew[i];
sl@0	5294	int minI = i;
sl@0	5295	for(j=i+1; j<k; j++){
sl@0	5296	if( pgnoNew[j]<(unsigned)minV ){
sl@0	5297	minI = j;
sl@0	5298	minV = pgnoNew[j];
sl@0	5299	}
sl@0	5300	}
sl@0	5301	if( minI>i ){
sl@0	5302	int t;
sl@0	5303	MemPage *pT;
sl@0	5304	t = pgnoNew[i];
sl@0	5305	pT = apNew[i];
sl@0	5306	pgnoNew[i] = pgnoNew[minI];
sl@0	5307	apNew[i] = apNew[minI];
sl@0	5308	pgnoNew[minI] = t;
sl@0	5309	apNew[minI] = pT;
sl@0	5310	}
sl@0	5311	}
sl@0	5312	TRACE(("BALANCE: old: %d %d %d new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n",
sl@0	5313	pgnoOld[0],
sl@0	5314	nOld>=2 ? pgnoOld[1] : 0,
sl@0	5315	nOld>=3 ? pgnoOld[2] : 0,
sl@0	5316	pgnoNew[0], szNew[0],
sl@0	5317	nNew>=2 ? pgnoNew[1] : 0, nNew>=2 ? szNew[1] : 0,
sl@0	5318	nNew>=3 ? pgnoNew[2] : 0, nNew>=3 ? szNew[2] : 0,
sl@0	5319	nNew>=4 ? pgnoNew[3] : 0, nNew>=4 ? szNew[3] : 0,
sl@0	5320	nNew>=5 ? pgnoNew[4] : 0, nNew>=5 ? szNew[4] : 0));
sl@0	5321
sl@0	5322	/*
sl@0	5323	** Evenly distribute the data in apCell[] across the new pages.
sl@0	5324	** Insert divider cells into pParent as necessary.
sl@0	5325	*/
sl@0	5326	j = 0;
sl@0	5327	for(i=0; i<nNew; i++){
sl@0	5328	/* Assemble the new sibling page. */
sl@0	5329	MemPage *pNew = apNew[i];
sl@0	5330	assert( j<nMaxCells );
sl@0	5331	assert( pNew->pgno==pgnoNew[i] );
sl@0	5332	zeroPage(pNew, pageFlags);
sl@0	5333	assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
sl@0	5334	assert( pNew->nCell>0 \|\| (nNew==1 && cntNew[0]==0) );
sl@0	5335	assert( pNew->nOverflow==0 );
sl@0	5336
sl@0	5337	/* If this is an auto-vacuum database, update the pointer map entries
sl@0	5338	** that point to the siblings that were rearranged. These can be: left
sl@0	5339	** children of cells, the right-child of the page, or overflow pages
sl@0	5340	** pointed to by cells.
sl@0	5341	*/
sl@0	5342	if( ISAUTOVACUUM ){
sl@0	5343	for(k=j; k<cntNew[i]; k++){
sl@0	5344	assert( k<nMaxCells );
sl@0	5345	if( aFrom[k]==0xFF \|\| apCopy[aFrom[k]]->pgno!=pNew->pgno ){
sl@0	5346	rc = ptrmapPutOvfl(pNew, k-j);
sl@0	5347	if( rc==SQLITE_OK && leafCorrection==0 ){
sl@0	5348	rc = ptrmapPut(pBt, get4byte(apCell[k]), PTRMAP_BTREE, pNew->pgno);
sl@0	5349	}
sl@0	5350	if( rc!=SQLITE_OK ){
sl@0	5351	goto balance_cleanup;
sl@0	5352	}
sl@0	5353	}
sl@0	5354	}
sl@0	5355	}
sl@0	5356
sl@0	5357	j = cntNew[i];
sl@0	5358
sl@0	5359	/* If the sibling page assembled above was not the right-most sibling,
sl@0	5360	** insert a divider cell into the parent page.
sl@0	5361	*/
sl@0	5362	if( i<nNew-1 && j<nCell ){
sl@0	5363	u8 *pCell;
sl@0	5364	u8 *pTemp;
sl@0	5365	int sz;
sl@0	5366
sl@0	5367	assert( j<nMaxCells );
sl@0	5368	pCell = apCell[j];
sl@0	5369	sz = szCell[j] + leafCorrection;
sl@0	5370	pTemp = &aSpace2[iSpace2];
sl@0	5371	if( !pNew->leaf ){
sl@0	5372	memcpy(&pNew->aData[8], pCell, 4);
sl@0	5373	if( ISAUTOVACUUM
sl@0	5374	&& (aFrom[j]==0xFF \|\| apCopy[aFrom[j]]->pgno!=pNew->pgno)
sl@0	5375	){
sl@0	5376	rc = ptrmapPut(pBt, get4byte(pCell), PTRMAP_BTREE, pNew->pgno);
sl@0	5377	if( rc!=SQLITE_OK ){
sl@0	5378	goto balance_cleanup;
sl@0	5379	}
sl@0	5380	}
sl@0	5381	}else if( leafData ){
sl@0	5382	/* If the tree is a leaf-data tree, and the siblings are leaves,
sl@0	5383	** then there is no divider cell in apCell[]. Instead, the divider
sl@0	5384	** cell consists of the integer key for the right-most cell of
sl@0	5385	** the sibling-page assembled above only.
sl@0	5386	*/
sl@0	5387	CellInfo info;
sl@0	5388	j--;
sl@0	5389	sqlite3BtreeParseCellPtr(pNew, apCell[j], &info);
sl@0	5390	pCell = pTemp;
sl@0	5391	fillInCell(pParent, pCell, 0, info.nKey, 0, 0, 0, &sz);
sl@0	5392	pTemp = 0;
sl@0	5393	}else{
sl@0	5394	pCell -= 4;
sl@0	5395	/* Obscure case for non-leaf-data trees: If the cell at pCell was
sl@0	5396	** previously stored on a leaf node, and its reported size was 4
sl@0	5397	** bytes, then it may actually be smaller than this
sl@0	5398	** (see sqlite3BtreeParseCellPtr(), 4 bytes is the minimum size of
sl@0	5399	** any cell). But it is important to pass the correct size to
sl@0	5400	** insertCell(), so reparse the cell now.
sl@0	5401	**
sl@0	5402	** Note that this can never happen in an SQLite data file, as all
sl@0	5403	** cells are at least 4 bytes. It only happens in b-trees used
sl@0	5404	** to evaluate "IN (SELECT ...)" and similar clauses.
sl@0	5405	*/
sl@0	5406	if( szCell[j]==4 ){
sl@0	5407	assert(leafCorrection==4);
sl@0	5408	sz = cellSizePtr(pParent, pCell);
sl@0	5409	}
sl@0	5410	}
sl@0	5411	iSpace2 += sz;
sl@0	5412	assert( sz<=pBt->pageSize/4 );
sl@0	5413	assert( iSpace2<=pBt->pageSize );
sl@0	5414	rc = insertCell(pParent, nxDiv, pCell, sz, pTemp, 4);
sl@0	5415	if( rc!=SQLITE_OK ) goto balance_cleanup;
sl@0	5416	put4byte(findOverflowCell(pParent,nxDiv), pNew->pgno);
sl@0	5417
sl@0	5418	/* If this is an auto-vacuum database, and not a leaf-data tree,
sl@0	5419	** then update the pointer map with an entry for the overflow page
sl@0	5420	** that the cell just inserted points to (if any).
sl@0	5421	*/
sl@0	5422	if( ISAUTOVACUUM && !leafData ){
sl@0	5423	rc = ptrmapPutOvfl(pParent, nxDiv);
sl@0	5424	if( rc!=SQLITE_OK ){
sl@0	5425	goto balance_cleanup;
sl@0	5426	}
sl@0	5427	}
sl@0	5428	j++;
sl@0	5429	nxDiv++;
sl@0	5430	}
sl@0	5431
sl@0	5432	/* Set the pointer-map entry for the new sibling page. */
sl@0	5433	if( ISAUTOVACUUM ){
sl@0	5434	rc = ptrmapPut(pBt, pNew->pgno, PTRMAP_BTREE, pParent->pgno);
sl@0	5435	if( rc!=SQLITE_OK ){
sl@0	5436	goto balance_cleanup;
sl@0	5437	}
sl@0	5438	}
sl@0	5439	}
sl@0	5440	assert( j==nCell );
sl@0	5441	assert( nOld>0 );
sl@0	5442	assert( nNew>0 );
sl@0	5443	if( (pageFlags & PTF_LEAF)==0 ){
sl@0	5444	u8 *zChild = &apCopy[nOld-1]->aData[8];
sl@0	5445	memcpy(&apNew[nNew-1]->aData[8], zChild, 4);
sl@0	5446	if( ISAUTOVACUUM ){
sl@0	5447	rc = ptrmapPut(pBt, get4byte(zChild), PTRMAP_BTREE, apNew[nNew-1]->pgno);
sl@0	5448	if( rc!=SQLITE_OK ){
sl@0	5449	goto balance_cleanup;
sl@0	5450	}
sl@0	5451	}
sl@0	5452	}
sl@0	5453	if( nxDiv==pParent->nCell+pParent->nOverflow ){
sl@0	5454	/* Right-most sibling is the right-most child of pParent */
sl@0	5455	put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew[nNew-1]);
sl@0	5456	}else{
sl@0	5457	/* Right-most sibling is the left child of the first entry in pParent
sl@0	5458	** past the right-most divider entry */
sl@0	5459	put4byte(findOverflowCell(pParent, nxDiv), pgnoNew[nNew-1]);
sl@0	5460	}
sl@0	5461
sl@0	5462	/*
sl@0	5463	** Balance the parent page. Note that the current page (pPage) might
sl@0	5464	** have been added to the freelist so it might no longer be initialized.
sl@0	5465	** But the parent page will always be initialized.
sl@0	5466	*/
sl@0	5467	assert( pParent->isInit );
sl@0	5468	sqlite3ScratchFree(apCell);
sl@0	5469	apCell = 0;
sl@0	5470	releasePage(pPage);
sl@0	5471	pCur->iPage--;
sl@0	5472	rc = balance(pCur, 0);
sl@0	5473
sl@0	5474	/*
sl@0	5475	** Cleanup before returning.
sl@0	5476	*/
sl@0	5477	balance_cleanup:
sl@0	5478	sqlite3PageFree(aSpace2);
sl@0	5479	sqlite3ScratchFree(apCell);
sl@0	5480	for(i=0; i<nOld; i++){
sl@0	5481	releasePage(apOld[i]);
sl@0	5482	}
sl@0	5483	for(i=0; i<nNew; i++){
sl@0	5484	releasePage(apNew[i]);
sl@0	5485	}
sl@0	5486
sl@0	5487	/* releasePage(pParent); */
sl@0	5488	TRACE(("BALANCE: finished with %d: old=%d new=%d cells=%d\n",
sl@0	5489	pPage->pgno, nOld, nNew, nCell));
sl@0	5490
sl@0	5491	return rc;
sl@0	5492	}
sl@0	5493
sl@0	5494	/*
sl@0	5495	** This routine is called for the root page of a btree when the root
sl@0	5496	** page contains no cells. This is an opportunity to make the tree
sl@0	5497	** shallower by one level.
sl@0	5498	*/
sl@0	5499	static int balance_shallower(BtCursor *pCur){
sl@0	5500	MemPage pPage; / Root page of B-Tree */
sl@0	5501	MemPage pChild; / The only child page of pPage */
sl@0	5502	Pgno pgnoChild; /* Page number for pChild */
sl@0	5503	int rc = SQLITE_OK; /* Return code from subprocedures */
sl@0	5504	BtShared pBt; / The main BTree structure */
sl@0	5505	int mxCellPerPage; /* Maximum number of cells per page */
sl@0	5506	u8 *apCell; / All cells from pages being balanced */
sl@0	5507	u16 szCell; / Local size of all cells */
sl@0	5508
sl@0	5509	assert( pCur->iPage==0 );
sl@0	5510	pPage = pCur->apPage[0];
sl@0	5511
sl@0	5512	assert( pPage->nCell==0 );
sl@0	5513	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	5514	pBt = pPage->pBt;
sl@0	5515	mxCellPerPage = MX_CELL(pBt);
sl@0	5516	apCell = sqlite3Malloc( mxCellPerPage(sizeof(u8)+sizeof(u16)) );
sl@0	5517	if( apCell==0 ) return SQLITE_NOMEM;
sl@0	5518	szCell = (u16*)&apCell[mxCellPerPage];
sl@0	5519	if( pPage->leaf ){
sl@0	5520	/* The table is completely empty */
sl@0	5521	TRACE(("BALANCE: empty table %d\n", pPage->pgno));
sl@0	5522	}else{
sl@0	5523	/* The root page is empty but has one child. Transfer the
sl@0	5524	** information from that one child into the root page if it
sl@0	5525	** will fit. This reduces the depth of the tree by one.
sl@0	5526	**
sl@0	5527	** If the root page is page 1, it has less space available than
sl@0	5528	** its child (due to the 100 byte header that occurs at the beginning
sl@0	5529	** of the database fle), so it might not be able to hold all of the
sl@0	5530	** information currently contained in the child. If this is the
sl@0	5531	** case, then do not do the transfer. Leave page 1 empty except
sl@0	5532	** for the right-pointer to the child page. The child page becomes
sl@0	5533	** the virtual root of the tree.
sl@0	5534	*/
sl@0	5535	VVA_ONLY( pCur->pagesShuffled = 1 );
sl@0	5536	pgnoChild = get4byte(&pPage->aData[pPage->hdrOffset+8]);
sl@0	5537	assert( pgnoChild>0 );
sl@0	5538	assert( pgnoChild<=pagerPagecount(pPage->pBt->pPager) );
sl@0	5539	rc = sqlite3BtreeGetPage(pPage->pBt, pgnoChild, &pChild, 0);
sl@0	5540	if( rc ) goto end_shallow_balance;
sl@0	5541	if( pPage->pgno==1 ){
sl@0	5542	rc = sqlite3BtreeInitPage(pChild);
sl@0	5543	if( rc ) goto end_shallow_balance;
sl@0	5544	assert( pChild->nOverflow==0 );
sl@0	5545	if( pChild->nFree>=100 ){
sl@0	5546	/* The child information will fit on the root page, so do the
sl@0	5547	** copy */
sl@0	5548	int i;
sl@0	5549	zeroPage(pPage, pChild->aData[0]);
sl@0	5550	for(i=0; i<pChild->nCell; i++){
sl@0	5551	apCell[i] = findCell(pChild,i);
sl@0	5552	szCell[i] = cellSizePtr(pChild, apCell[i]);
sl@0	5553	}
sl@0	5554	assemblePage(pPage, pChild->nCell, apCell, szCell);
sl@0	5555	/* Copy the right-pointer of the child to the parent. */
sl@0	5556	put4byte(&pPage->aData[pPage->hdrOffset+8],
sl@0	5557	get4byte(&pChild->aData[pChild->hdrOffset+8]));
sl@0	5558	freePage(pChild);
sl@0	5559	TRACE(("BALANCE: child %d transfer to page 1\n", pChild->pgno));
sl@0	5560	}else{
sl@0	5561	/* The child has more information that will fit on the root.
sl@0	5562	** The tree is already balanced. Do nothing. */
sl@0	5563	TRACE(("BALANCE: child %d will not fit on page 1\n", pChild->pgno));
sl@0	5564	}
sl@0	5565	}else{
sl@0	5566	memcpy(pPage->aData, pChild->aData, pPage->pBt->usableSize);
sl@0	5567	pPage->isInit = 0;
sl@0	5568	rc = sqlite3BtreeInitPage(pPage);
sl@0	5569	assert( rc==SQLITE_OK );
sl@0	5570	freePage(pChild);
sl@0	5571	TRACE(("BALANCE: transfer child %d into root %d\n",
sl@0	5572	pChild->pgno, pPage->pgno));
sl@0	5573	}
sl@0	5574	assert( pPage->nOverflow==0 );
sl@0	5575	if( ISAUTOVACUUM ){
sl@0	5576	rc = setChildPtrmaps(pPage);
sl@0	5577	}
sl@0	5578	releasePage(pChild);
sl@0	5579	}
sl@0	5580	end_shallow_balance:
sl@0	5581	sqlite3_free(apCell);
sl@0	5582	return rc;
sl@0	5583	}
sl@0	5584
sl@0	5585
sl@0	5586	/*
sl@0	5587	** The root page is overfull
sl@0	5588	**
sl@0	5589	** When this happens, Create a new child page and copy the
sl@0	5590	** contents of the root into the child. Then make the root
sl@0	5591	** page an empty page with rightChild pointing to the new
sl@0	5592	** child. Finally, call balance_internal() on the new child
sl@0	5593	** to cause it to split.
sl@0	5594	*/
sl@0	5595	static int balance_deeper(BtCursor *pCur){
sl@0	5596	int rc; /* Return value from subprocedures */
sl@0	5597	MemPage pPage; / Pointer to the root page */
sl@0	5598	MemPage pChild; / Pointer to a new child page */
sl@0	5599	Pgno pgnoChild; /* Page number of the new child page */
sl@0	5600	BtShared pBt; / The BTree */
sl@0	5601	int usableSize; /* Total usable size of a page */
sl@0	5602	u8 data; / Content of the parent page */
sl@0	5603	u8 cdata; / Content of the child page */
sl@0	5604	int hdr; /* Offset to page header in parent */
sl@0	5605	int cbrk; /* Offset to content of first cell in parent */
sl@0	5606
sl@0	5607	assert( pCur->iPage==0 );
sl@0	5608	assert( pCur->apPage[0]->nOverflow>0 );
sl@0	5609
sl@0	5610	VVA_ONLY( pCur->pagesShuffled = 1 );
sl@0	5611	pPage = pCur->apPage[0];
sl@0	5612	pBt = pPage->pBt;
sl@0	5613	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	5614	rc = allocateBtreePage(pBt, &pChild, &pgnoChild, pPage->pgno, 0);
sl@0	5615	if( rc ) return rc;
sl@0	5616	assert( sqlite3PagerIswriteable(pChild->pDbPage) );
sl@0	5617	usableSize = pBt->usableSize;
sl@0	5618	data = pPage->aData;
sl@0	5619	hdr = pPage->hdrOffset;
sl@0	5620	cbrk = get2byte(&data[hdr+5]);
sl@0	5621	cdata = pChild->aData;
sl@0	5622	memcpy(cdata, &data[hdr], pPage->cellOffset+2*pPage->nCell-hdr);
sl@0	5623	memcpy(&cdata[cbrk], &data[cbrk], usableSize-cbrk);
sl@0	5624
sl@0	5625	rc = sqlite3BtreeInitPage(pChild);
sl@0	5626	if( rc==SQLITE_OK ){
sl@0	5627	int nCopy = pPage->nOverflow*sizeof(pPage->aOvfl[0]);
sl@0	5628	memcpy(pChild->aOvfl, pPage->aOvfl, nCopy);
sl@0	5629	pChild->nOverflow = pPage->nOverflow;
sl@0	5630	if( pChild->nOverflow ){
sl@0	5631	pChild->nFree = 0;
sl@0	5632	}
sl@0	5633	assert( pChild->nCell==pPage->nCell );
sl@0	5634	zeroPage(pPage, pChild->aData[0] & ~PTF_LEAF);
sl@0	5635	put4byte(&pPage->aData[pPage->hdrOffset+8], pgnoChild);
sl@0	5636	TRACE(("BALANCE: copy root %d into %d\n", pPage->pgno, pChild->pgno));
sl@0	5637	if( ISAUTOVACUUM ){
sl@0	5638	rc = ptrmapPut(pBt, pChild->pgno, PTRMAP_BTREE, pPage->pgno);
sl@0	5639	if( rc==SQLITE_OK ){
sl@0	5640	rc = setChildPtrmaps(pChild);
sl@0	5641	}
sl@0	5642	}
sl@0	5643	}
sl@0	5644
sl@0	5645	if( rc==SQLITE_OK ){
sl@0	5646	pCur->iPage++;
sl@0	5647	pCur->apPage[1] = pChild;
sl@0	5648	pCur->aiIdx[0] = 0;
sl@0	5649	rc = balance_nonroot(pCur);
sl@0	5650	}else{
sl@0	5651	releasePage(pChild);
sl@0	5652	}
sl@0	5653
sl@0	5654	return rc;
sl@0	5655	}
sl@0	5656
sl@0	5657	/*
sl@0	5658	** The page that pCur currently points to has just been modified in
sl@0	5659	** some way. This function figures out if this modification means the
sl@0	5660	** tree needs to be balanced, and if so calls the appropriate balancing
sl@0	5661	** routine.
sl@0	5662	**
sl@0	5663	** Parameter isInsert is true if a new cell was just inserted into the
sl@0	5664	** page, or false otherwise.
sl@0	5665	*/
sl@0	5666	static int balance(BtCursor *pCur, int isInsert){
sl@0	5667	int rc = SQLITE_OK;
sl@0	5668	MemPage *pPage = pCur->apPage[pCur->iPage];
sl@0	5669
sl@0	5670	assert( sqlite3_mutex_held(pPage->pBt->mutex) );
sl@0	5671	if( pCur->iPage==0 ){
sl@0	5672	rc = sqlite3PagerWrite(pPage->pDbPage);
sl@0	5673	if( rc==SQLITE_OK && pPage->nOverflow>0 ){
sl@0	5674	rc = balance_deeper(pCur);
sl@0	5675	}
sl@0	5676	if( rc==SQLITE_OK && pPage->nCell==0 ){
sl@0	5677	rc = balance_shallower(pCur);
sl@0	5678	}
sl@0	5679	}else{
sl@0	5680	if( pPage->nOverflow>0 \|\|
sl@0	5681	(!isInsert && pPage->nFree>pPage->pBt->usableSize*2/3) ){
sl@0	5682	rc = balance_nonroot(pCur);
sl@0	5683	}
sl@0	5684	}
sl@0	5685	return rc;
sl@0	5686	}
sl@0	5687
sl@0	5688	/*
sl@0	5689	** This routine checks all cursors that point to table pgnoRoot.
sl@0	5690	** If any of those cursors were opened with wrFlag==0 in a different
sl@0	5691	** database connection (a database connection that shares the pager
sl@0	5692	** cache with the current connection) and that other connection
sl@0	5693	** is not in the ReadUncommmitted state, then this routine returns
sl@0	5694	** SQLITE_LOCKED.
sl@0	5695	**
sl@0	5696	** As well as cursors with wrFlag==0, cursors with wrFlag==1 and
sl@0	5697	** isIncrblobHandle==1 are also considered 'read' cursors. Incremental
sl@0	5698	** blob cursors are used for both reading and writing.
sl@0	5699	**
sl@0	5700	** When pgnoRoot is the root page of an intkey table, this function is also
sl@0	5701	** responsible for invalidating incremental blob cursors when the table row
sl@0	5702	** on which they are opened is deleted or modified. Cursors are invalidated
sl@0	5703	** according to the following rules:
sl@0	5704	**
sl@0	5705	** 1) When BtreeClearTable() is called to completely delete the contents
sl@0	5706	** of a B-Tree table, pExclude is set to zero and parameter iRow is
sl@0	5707	** set to non-zero. In this case all incremental blob cursors open
sl@0	5708	** on the table rooted at pgnoRoot are invalidated.
sl@0	5709	**
sl@0	5710	** 2) When BtreeInsert(), BtreeDelete() or BtreePutData() is called to
sl@0	5711	** modify a table row via an SQL statement, pExclude is set to the
sl@0	5712	** write cursor used to do the modification and parameter iRow is set
sl@0	5713	** to the integer row id of the B-Tree entry being modified. Unless
sl@0	5714	** pExclude is itself an incremental blob cursor, then all incremental
sl@0	5715	** blob cursors open on row iRow of the B-Tree are invalidated.
sl@0	5716	**
sl@0	5717	** 3) If both pExclude and iRow are set to zero, no incremental blob
sl@0	5718	** cursors are invalidated.
sl@0	5719	*/
sl@0	5720	static int checkReadLocks(
sl@0	5721	Btree *pBtree,
sl@0	5722	Pgno pgnoRoot,
sl@0	5723	BtCursor *pExclude,
sl@0	5724	i64 iRow
sl@0	5725	){
sl@0	5726	BtCursor *p;
sl@0	5727	BtShared *pBt = pBtree->pBt;
sl@0	5728	sqlite3 *db = pBtree->db;
sl@0	5729	assert( sqlite3BtreeHoldsMutex(pBtree) );
sl@0	5730	for(p=pBt->pCursor; p; p=p->pNext){
sl@0	5731	if( p==pExclude ) continue;
sl@0	5732	if( p->pgnoRoot!=pgnoRoot ) continue;
sl@0	5733	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	5734	if( p->isIncrblobHandle && (
sl@0	5735	(!pExclude && iRow)
sl@0	5736	\|\| (pExclude && !pExclude->isIncrblobHandle && p->info.nKey==iRow)
sl@0	5737	)){
sl@0	5738	p->eState = CURSOR_INVALID;
sl@0	5739	}
sl@0	5740	#endif
sl@0	5741	if( p->eState!=CURSOR_VALID ) continue;
sl@0	5742	if( p->wrFlag==0
sl@0	5743	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	5744	\|\| p->isIncrblobHandle
sl@0	5745	#endif
sl@0	5746	){
sl@0	5747	sqlite3 *dbOther = p->pBtree->db;
sl@0	5748	if( dbOther==0 \|\|
sl@0	5749	(dbOther!=db && (dbOther->flags & SQLITE_ReadUncommitted)==0) ){
sl@0	5750	return SQLITE_LOCKED;
sl@0	5751	}
sl@0	5752	}
sl@0	5753	}
sl@0	5754	return SQLITE_OK;
sl@0	5755	}
sl@0	5756
sl@0	5757	/*
sl@0	5758	** Insert a new record into the BTree. The key is given by (pKey,nKey)
sl@0	5759	** and the data is given by (pData,nData). The cursor is used only to
sl@0	5760	** define what table the record should be inserted into. The cursor
sl@0	5761	** is left pointing at a random location.
sl@0	5762	**
sl@0	5763	** For an INTKEY table, only the nKey value of the key is used. pKey is
sl@0	5764	** ignored. For a ZERODATA table, the pData and nData are both ignored.
sl@0	5765	*/
sl@0	5766	int sqlite3BtreeInsert(
sl@0	5767	BtCursor pCur, / Insert data into the table of this cursor */
sl@0	5768	const void pKey, i64 nKey, / The key of the new record */
sl@0	5769	const void pData, int nData, / The data of the new record */
sl@0	5770	int nZero, /* Number of extra 0 bytes to append to data */
sl@0	5771	int appendBias /* True if this is likely an append */
sl@0	5772	){
sl@0	5773	int rc;
sl@0	5774	int loc;
sl@0	5775	int szNew;
sl@0	5776	int idx;
sl@0	5777	MemPage *pPage;
sl@0	5778	Btree *p = pCur->pBtree;
sl@0	5779	BtShared *pBt = p->pBt;
sl@0	5780	unsigned char *oldCell;
sl@0	5781	unsigned char *newCell = 0;
sl@0	5782
sl@0	5783	assert( cursorHoldsMutex(pCur) );
sl@0	5784	if( pBt->inTransaction!=TRANS_WRITE ){
sl@0	5785	/* Must start a transaction before doing an insert */
sl@0	5786	rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	5787	return rc;
sl@0	5788	}
sl@0	5789	assert( !pBt->readOnly );
sl@0	5790	if( !pCur->wrFlag ){
sl@0	5791	return SQLITE_PERM; /* Cursor not open for writing */
sl@0	5792	}
sl@0	5793	if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur, nKey) ){
sl@0	5794	return SQLITE_LOCKED; /* The table pCur points to has a read lock */
sl@0	5795	}
sl@0	5796	if( pCur->eState==CURSOR_FAULT ){
sl@0	5797	return pCur->skip;
sl@0	5798	}
sl@0	5799
sl@0	5800	/* Save the positions of any other cursors open on this table */
sl@0	5801	sqlite3BtreeClearCursor(pCur);
sl@0	5802	if(
sl@0	5803	SQLITE_OK!=(rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur)) \|\|
sl@0	5804	SQLITE_OK!=(rc = sqlite3BtreeMoveto(pCur, pKey, nKey, appendBias, &loc))
sl@0	5805	){
sl@0	5806	return rc;
sl@0	5807	}
sl@0	5808
sl@0	5809	pPage = pCur->apPage[pCur->iPage];
sl@0	5810	assert( pPage->intKey \|\| nKey>=0 );
sl@0	5811	assert( pPage->leaf \|\| !pPage->intKey );
sl@0	5812	TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
sl@0	5813	pCur->pgnoRoot, nKey, nData, pPage->pgno,
sl@0	5814	loc==0 ? "overwrite" : "new entry"));
sl@0	5815	assert( pPage->isInit );
sl@0	5816	allocateTempSpace(pBt);
sl@0	5817	newCell = pBt->pTmpSpace;
sl@0	5818	if( newCell==0 ) return SQLITE_NOMEM;
sl@0	5819	rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
sl@0	5820	if( rc ) goto end_insert;
sl@0	5821	assert( szNew==cellSizePtr(pPage, newCell) );
sl@0	5822	assert( szNew<=MX_CELL_SIZE(pBt) );
sl@0	5823	idx = pCur->aiIdx[pCur->iPage];
sl@0	5824	if( loc==0 && CURSOR_VALID==pCur->eState ){
sl@0	5825	u16 szOld;
sl@0	5826	assert( idx<pPage->nCell );
sl@0	5827	rc = sqlite3PagerWrite(pPage->pDbPage);
sl@0	5828	if( rc ){
sl@0	5829	goto end_insert;
sl@0	5830	}
sl@0	5831	oldCell = findCell(pPage, idx);
sl@0	5832	if( !pPage->leaf ){
sl@0	5833	memcpy(newCell, oldCell, 4);
sl@0	5834	}
sl@0	5835	szOld = cellSizePtr(pPage, oldCell);
sl@0	5836	rc = clearCell(pPage, oldCell);
sl@0	5837	if( rc ) goto end_insert;
sl@0	5838	rc = dropCell(pPage, idx, szOld);
sl@0	5839	if( rc ) goto end_insert;
sl@0	5840	}else if( loc<0 && pPage->nCell>0 ){
sl@0	5841	assert( pPage->leaf );
sl@0	5842	idx = ++pCur->aiIdx[pCur->iPage];
sl@0	5843	pCur->info.nSize = 0;
sl@0	5844	pCur->validNKey = 0;
sl@0	5845	}else{
sl@0	5846	assert( pPage->leaf );
sl@0	5847	}
sl@0	5848	rc = insertCell(pPage, idx, newCell, szNew, 0, 0);
sl@0	5849	if( rc!=SQLITE_OK ) goto end_insert;
sl@0	5850	rc = balance(pCur, 1);
sl@0	5851	if( rc==SQLITE_OK ){
sl@0	5852	moveToRoot(pCur);
sl@0	5853	}
sl@0	5854	end_insert:
sl@0	5855	return rc;
sl@0	5856	}
sl@0	5857
sl@0	5858	/*
sl@0	5859	** Delete the entry that the cursor is pointing to. The cursor
sl@0	5860	** is left pointing at a arbitrary location.
sl@0	5861	*/
sl@0	5862	int sqlite3BtreeDelete(BtCursor *pCur){
sl@0	5863	MemPage *pPage = pCur->apPage[pCur->iPage];
sl@0	5864	int idx;
sl@0	5865	unsigned char *pCell;
sl@0	5866	int rc;
sl@0	5867	Pgno pgnoChild = 0;
sl@0	5868	Btree *p = pCur->pBtree;
sl@0	5869	BtShared *pBt = p->pBt;
sl@0	5870
sl@0	5871	assert( cursorHoldsMutex(pCur) );
sl@0	5872	assert( pPage->isInit );
sl@0	5873	if( pBt->inTransaction!=TRANS_WRITE ){
sl@0	5874	/* Must start a transaction before doing a delete */
sl@0	5875	rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	5876	return rc;
sl@0	5877	}
sl@0	5878	assert( !pBt->readOnly );
sl@0	5879	if( pCur->eState==CURSOR_FAULT ){
sl@0	5880	return pCur->skip;
sl@0	5881	}
sl@0	5882	if( pCur->aiIdx[pCur->iPage]>=pPage->nCell ){
sl@0	5883	return SQLITE_ERROR; /* The cursor is not pointing to anything */
sl@0	5884	}
sl@0	5885	if( !pCur->wrFlag ){
sl@0	5886	return SQLITE_PERM; /* Did not open this cursor for writing */
sl@0	5887	}
sl@0	5888	if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur, pCur->info.nKey) ){
sl@0	5889	return SQLITE_LOCKED; /* The table pCur points to has a read lock */
sl@0	5890	}
sl@0	5891
sl@0	5892	/* Restore the current cursor position (a no-op if the cursor is not in
sl@0	5893	** CURSOR_REQUIRESEEK state) and save the positions of any other cursors
sl@0	5894	** open on the same table. Then call sqlite3PagerWrite() on the page
sl@0	5895	** that the entry will be deleted from.
sl@0	5896	*/
sl@0	5897	if(
sl@0	5898	(rc = restoreCursorPosition(pCur))!=0 \|\|
sl@0	5899	(rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur))!=0 \|\|
sl@0	5900	(rc = sqlite3PagerWrite(pPage->pDbPage))!=0
sl@0	5901	){
sl@0	5902	return rc;
sl@0	5903	}
sl@0	5904
sl@0	5905	/* Locate the cell within its page and leave pCell pointing to the
sl@0	5906	** data. The clearCell() call frees any overflow pages associated with the
sl@0	5907	** cell. The cell itself is still intact.
sl@0	5908	*/
sl@0	5909	idx = pCur->aiIdx[pCur->iPage];
sl@0	5910	pCell = findCell(pPage, idx);
sl@0	5911	if( !pPage->leaf ){
sl@0	5912	pgnoChild = get4byte(pCell);
sl@0	5913	}
sl@0	5914	rc = clearCell(pPage, pCell);
sl@0	5915	if( rc ){
sl@0	5916	return rc;
sl@0	5917	}
sl@0	5918
sl@0	5919	if( !pPage->leaf ){
sl@0	5920	/*
sl@0	5921	** The entry we are about to delete is not a leaf so if we do not
sl@0	5922	** do something we will leave a hole on an internal page.
sl@0	5923	** We have to fill the hole by moving in a cell from a leaf. The
sl@0	5924	** next Cell after the one to be deleted is guaranteed to exist and
sl@0	5925	** to be a leaf so we can use it.
sl@0	5926	*/
sl@0	5927	BtCursor leafCur;
sl@0	5928	MemPage *pLeafPage;
sl@0	5929
sl@0	5930	unsigned char *pNext;
sl@0	5931	int notUsed;
sl@0	5932	unsigned char *tempCell = 0;
sl@0	5933	assert( !pPage->intKey );
sl@0	5934	sqlite3BtreeGetTempCursor(pCur, &leafCur);
sl@0	5935	rc = sqlite3BtreeNext(&leafCur, &notUsed);
sl@0	5936	if( rc==SQLITE_OK ){
sl@0	5937	assert( leafCur.aiIdx[leafCur.iPage]==0 );
sl@0	5938	pLeafPage = leafCur.apPage[leafCur.iPage];
sl@0	5939	rc = sqlite3PagerWrite(pLeafPage->pDbPage);
sl@0	5940	}
sl@0	5941	if( rc==SQLITE_OK ){
sl@0	5942	int leafCursorInvalid = 0;
sl@0	5943	u16 szNext;
sl@0	5944	TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n",
sl@0	5945	pCur->pgnoRoot, pPage->pgno, pLeafPage->pgno));
sl@0	5946	dropCell(pPage, idx, cellSizePtr(pPage, pCell));
sl@0	5947	pNext = findCell(pLeafPage, 0);
sl@0	5948	szNext = cellSizePtr(pLeafPage, pNext);
sl@0	5949	assert( MX_CELL_SIZE(pBt)>=szNext+4 );
sl@0	5950	allocateTempSpace(pBt);
sl@0	5951	tempCell = pBt->pTmpSpace;
sl@0	5952	if( tempCell==0 ){
sl@0	5953	rc = SQLITE_NOMEM;
sl@0	5954	}
sl@0	5955	if( rc==SQLITE_OK ){
sl@0	5956	rc = insertCell(pPage, idx, pNext-4, szNext+4, tempCell, 0);
sl@0	5957	}
sl@0	5958
sl@0	5959
sl@0	5960	/* The "if" statement in the next code block is critical. The
sl@0	5961	** slightest error in that statement would allow SQLite to operate
sl@0	5962	** correctly most of the time but produce very rare failures. To
sl@0	5963	** guard against this, the following macros help to verify that
sl@0	5964	** the "if" statement is well tested.
sl@0	5965	*/
sl@0	5966	testcase( pPage->nOverflow==0 && pPage->nFree<pBt->usableSize*2/3
sl@0	5967	&& pLeafPage->nFree+2+szNext > pBt->usableSize*2/3 );
sl@0	5968	testcase( pPage->nOverflow==0 && pPage->nFree==pBt->usableSize*2/3
sl@0	5969	&& pLeafPage->nFree+2+szNext > pBt->usableSize*2/3 );
sl@0	5970	testcase( pPage->nOverflow==0 && pPage->nFree==pBt->usableSize*2/3+1
sl@0	5971	&& pLeafPage->nFree+2+szNext > pBt->usableSize*2/3 );
sl@0	5972	testcase( pPage->nOverflow>0 && pPage->nFree<=pBt->usableSize*2/3
sl@0	5973	&& pLeafPage->nFree+2+szNext > pBt->usableSize*2/3 );
sl@0	5974	testcase( (pPage->nOverflow>0 \|\| (pPage->nFree > pBt->usableSize*2/3))
sl@0	5975	&& pLeafPage->nFree+2+szNext == pBt->usableSize*2/3 );
sl@0	5976
sl@0	5977
sl@0	5978	if( (pPage->nOverflow>0 \|\| (pPage->nFree > pBt->usableSize*2/3)) &&
sl@0	5979	(pLeafPage->nFree+2+szNext > pBt->usableSize*2/3)
sl@0	5980	){
sl@0	5981	/* This branch is taken if the internal node is now either overflowing
sl@0	5982	** or underfull and the leaf node will be underfull after the just cell
sl@0	5983	** copied to the internal node is deleted from it. This is a special
sl@0	5984	** case because the call to balance() to correct the internal node
sl@0	5985	** may change the tree structure and invalidate the contents of
sl@0	5986	** the leafCur.apPage[] and leafCur.aiIdx[] arrays, which will be
sl@0	5987	** used by the balance() required to correct the underfull leaf
sl@0	5988	** node.
sl@0	5989	**
sl@0	5990	** The formula used in the expression above are based on facets of
sl@0	5991	** the SQLite file-format that do not change over time.
sl@0	5992	*/
sl@0	5993	testcase( pPage->nFree==pBt->usableSize*2/3+1 );
sl@0	5994	testcase( pLeafPage->nFree+2+szNext==pBt->usableSize*2/3+1 );
sl@0	5995	leafCursorInvalid = 1;
sl@0	5996	}
sl@0	5997
sl@0	5998	if( rc==SQLITE_OK ){
sl@0	5999	put4byte(findOverflowCell(pPage, idx), pgnoChild);
sl@0	6000	VVA_ONLY( pCur->pagesShuffled = 0 );
sl@0	6001	rc = balance(pCur, 0);
sl@0	6002	}
sl@0	6003
sl@0	6004	if( rc==SQLITE_OK && leafCursorInvalid ){
sl@0	6005	/* The leaf-node is now underfull and so the tree needs to be
sl@0	6006	** rebalanced. However, the balance() operation on the internal
sl@0	6007	** node above may have modified the structure of the B-Tree and
sl@0	6008	** so the current contents of leafCur.apPage[] and leafCur.aiIdx[]
sl@0	6009	** may not be trusted.
sl@0	6010	**
sl@0	6011	** It is not possible to copy the ancestry from pCur, as the same
sl@0	6012	** balance() call has invalidated the pCur->apPage[] and aiIdx[]
sl@0	6013	** arrays.
sl@0	6014	**
sl@0	6015	** The call to saveCursorPosition() below internally saves the
sl@0	6016	** key that leafCur is currently pointing to. Currently, there
sl@0	6017	** are two copies of that key in the tree - one here on the leaf
sl@0	6018	** page and one on some internal node in the tree. The copy on
sl@0	6019	** the leaf node is always the next key in tree-order after the
sl@0	6020	** copy on the internal node. So, the call to sqlite3BtreeNext()
sl@0	6021	** calls restoreCursorPosition() to point the cursor to the copy
sl@0	6022	** stored on the internal node, then advances to the next entry,
sl@0	6023	** which happens to be the copy of the key on the internal node.
sl@0	6024	** Net effect: leafCur is pointing back to the duplicate cell
sl@0	6025	** that needs to be removed, and the leafCur.apPage[] and
sl@0	6026	** leafCur.aiIdx[] arrays are correct.
sl@0	6027	*/
sl@0	6028	VVA_ONLY( Pgno leafPgno = pLeafPage->pgno );
sl@0	6029	rc = saveCursorPosition(&leafCur);
sl@0	6030	if( rc==SQLITE_OK ){
sl@0	6031	rc = sqlite3BtreeNext(&leafCur, &notUsed);
sl@0	6032	}
sl@0	6033	pLeafPage = leafCur.apPage[leafCur.iPage];
sl@0	6034	assert( pLeafPage->pgno==leafPgno );
sl@0	6035	assert( leafCur.aiIdx[leafCur.iPage]==0 );
sl@0	6036	}
sl@0	6037
sl@0	6038	if( rc==SQLITE_OK ){
sl@0	6039	dropCell(pLeafPage, 0, szNext);
sl@0	6040	VVA_ONLY( leafCur.pagesShuffled = 0 );
sl@0	6041	rc = balance(&leafCur, 0);
sl@0	6042	assert( leafCursorInvalid \|\| !leafCur.pagesShuffled
sl@0	6043	\|\| !pCur->pagesShuffled );
sl@0	6044	}
sl@0	6045	}
sl@0	6046	sqlite3BtreeReleaseTempCursor(&leafCur);
sl@0	6047	}else{
sl@0	6048	TRACE(("DELETE: table=%d delete from leaf %d\n",
sl@0	6049	pCur->pgnoRoot, pPage->pgno));
sl@0	6050	rc = dropCell(pPage, idx, cellSizePtr(pPage, pCell));
sl@0	6051	if( rc==SQLITE_OK ){
sl@0	6052	rc = balance(pCur, 0);
sl@0	6053	}
sl@0	6054	}
sl@0	6055	if( rc==SQLITE_OK ){
sl@0	6056	moveToRoot(pCur);
sl@0	6057	}
sl@0	6058	return rc;
sl@0	6059	}
sl@0	6060
sl@0	6061	/*
sl@0	6062	** Create a new BTree table. Write into *piTable the page
sl@0	6063	** number for the root page of the new table.
sl@0	6064	**
sl@0	6065	** The type of type is determined by the flags parameter. Only the
sl@0	6066	** following values of flags are currently in use. Other values for
sl@0	6067	** flags might not work:
sl@0	6068	**
sl@0	6069	** BTREE_INTKEY\|BTREE_LEAFDATA Used for SQL tables with rowid keys
sl@0	6070	** BTREE_ZERODATA Used for SQL indices
sl@0	6071	*/
sl@0	6072	static int btreeCreateTable(Btree p, int piTable, int flags){
sl@0	6073	BtShared *pBt = p->pBt;
sl@0	6074	MemPage *pRoot;
sl@0	6075	Pgno pgnoRoot;
sl@0	6076	int rc;
sl@0	6077
sl@0	6078	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	6079	if( pBt->inTransaction!=TRANS_WRITE ){
sl@0	6080	/* Must start a transaction first */
sl@0	6081	rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	6082	return rc;
sl@0	6083	}
sl@0	6084	assert( !pBt->readOnly );
sl@0	6085
sl@0	6086	#ifdef SQLITE_OMIT_AUTOVACUUM
sl@0	6087	rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
sl@0	6088	if( rc ){
sl@0	6089	return rc;
sl@0	6090	}
sl@0	6091	#else
sl@0	6092	if( pBt->autoVacuum ){
sl@0	6093	Pgno pgnoMove; /* Move a page here to make room for the root-page */
sl@0	6094	MemPage pPageMove; / The page to move to. */
sl@0	6095
sl@0	6096	/* Creating a new table may probably require moving an existing database
sl@0	6097	** to make room for the new tables root page. In case this page turns
sl@0	6098	** out to be an overflow page, delete all overflow page-map caches
sl@0	6099	** held by open cursors.
sl@0	6100	*/
sl@0	6101	invalidateAllOverflowCache(pBt);
sl@0	6102
sl@0	6103	/* Read the value of meta[3] from the database to determine where the
sl@0	6104	** root page of the new table should go. meta[3] is the largest root-page
sl@0	6105	** created so far, so the new root-page is (meta[3]+1).
sl@0	6106	*/
sl@0	6107	rc = sqlite3BtreeGetMeta(p, 4, &pgnoRoot);
sl@0	6108	if( rc!=SQLITE_OK ){
sl@0	6109	return rc;
sl@0	6110	}
sl@0	6111	pgnoRoot++;
sl@0	6112
sl@0	6113	/* The new root-page may not be allocated on a pointer-map page, or the
sl@0	6114	** PENDING_BYTE page.
sl@0	6115	*/
sl@0	6116	while( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) \|\|
sl@0	6117	pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
sl@0	6118	pgnoRoot++;
sl@0	6119	}
sl@0	6120	assert( pgnoRoot>=3 );
sl@0	6121
sl@0	6122	/* Allocate a page. The page that currently resides at pgnoRoot will
sl@0	6123	** be moved to the allocated page (unless the allocated page happens
sl@0	6124	** to reside at pgnoRoot).
sl@0	6125	*/
sl@0	6126	rc = allocateBtreePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
sl@0	6127	if( rc!=SQLITE_OK ){
sl@0	6128	return rc;
sl@0	6129	}
sl@0	6130
sl@0	6131	if( pgnoMove!=pgnoRoot ){
sl@0	6132	/* pgnoRoot is the page that will be used for the root-page of
sl@0	6133	** the new table (assuming an error did not occur). But we were
sl@0	6134	** allocated pgnoMove. If required (i.e. if it was not allocated
sl@0	6135	** by extending the file), the current page at position pgnoMove
sl@0	6136	** is already journaled.
sl@0	6137	*/
sl@0	6138	u8 eType;
sl@0	6139	Pgno iPtrPage;
sl@0	6140
sl@0	6141	releasePage(pPageMove);
sl@0	6142
sl@0	6143	/* Move the page currently at pgnoRoot to pgnoMove. */
sl@0	6144	rc = sqlite3BtreeGetPage(pBt, pgnoRoot, &pRoot, 0);
sl@0	6145	if( rc!=SQLITE_OK ){
sl@0	6146	return rc;
sl@0	6147	}
sl@0	6148	rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
sl@0	6149	if( rc!=SQLITE_OK \|\| eType==PTRMAP_ROOTPAGE \|\| eType==PTRMAP_FREEPAGE ){
sl@0	6150	releasePage(pRoot);
sl@0	6151	return rc;
sl@0	6152	}
sl@0	6153	assert( eType!=PTRMAP_ROOTPAGE );
sl@0	6154	assert( eType!=PTRMAP_FREEPAGE );
sl@0	6155	rc = sqlite3PagerWrite(pRoot->pDbPage);
sl@0	6156	if( rc!=SQLITE_OK ){
sl@0	6157	releasePage(pRoot);
sl@0	6158	return rc;
sl@0	6159	}
sl@0	6160	rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove, 0);
sl@0	6161	releasePage(pRoot);
sl@0	6162
sl@0	6163	/* Obtain the page at pgnoRoot */
sl@0	6164	if( rc!=SQLITE_OK ){
sl@0	6165	return rc;
sl@0	6166	}
sl@0	6167	rc = sqlite3BtreeGetPage(pBt, pgnoRoot, &pRoot, 0);
sl@0	6168	if( rc!=SQLITE_OK ){
sl@0	6169	return rc;
sl@0	6170	}
sl@0	6171	rc = sqlite3PagerWrite(pRoot->pDbPage);
sl@0	6172	if( rc!=SQLITE_OK ){
sl@0	6173	releasePage(pRoot);
sl@0	6174	return rc;
sl@0	6175	}
sl@0	6176	}else{
sl@0	6177	pRoot = pPageMove;
sl@0	6178	}
sl@0	6179
sl@0	6180	/* Update the pointer-map and meta-data with the new root-page number. */
sl@0	6181	rc = ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0);
sl@0	6182	if( rc ){
sl@0	6183	releasePage(pRoot);
sl@0	6184	return rc;
sl@0	6185	}
sl@0	6186	rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
sl@0	6187	if( rc ){
sl@0	6188	releasePage(pRoot);
sl@0	6189	return rc;
sl@0	6190	}
sl@0	6191
sl@0	6192	}else{
sl@0	6193	rc = allocateBtreePage(pBt, &pRoot, &pgnoRoot, 1, 0);
sl@0	6194	if( rc ) return rc;
sl@0	6195	}
sl@0	6196	#endif
sl@0	6197	assert( sqlite3PagerIswriteable(pRoot->pDbPage) );
sl@0	6198	zeroPage(pRoot, flags \| PTF_LEAF);
sl@0	6199	sqlite3PagerUnref(pRoot->pDbPage);
sl@0	6200	*piTable = (int)pgnoRoot;
sl@0	6201	return SQLITE_OK;
sl@0	6202	}
sl@0	6203	int sqlite3BtreeCreateTable(Btree p, int piTable, int flags){
sl@0	6204	int rc;
sl@0	6205	sqlite3BtreeEnter(p);
sl@0	6206	p->pBt->db = p->db;
sl@0	6207	rc = btreeCreateTable(p, piTable, flags);
sl@0	6208	sqlite3BtreeLeave(p);
sl@0	6209	return rc;
sl@0	6210	}
sl@0	6211
sl@0	6212	/*
sl@0	6213	** Erase the given database page and all its children. Return
sl@0	6214	** the page to the freelist.
sl@0	6215	*/
sl@0	6216	static int clearDatabasePage(
sl@0	6217	BtShared pBt, / The BTree that contains the table */
sl@0	6218	Pgno pgno, /* Page number to clear */
sl@0	6219	MemPage pParent, / Parent page. NULL for the root */
sl@0	6220	int freePageFlag /* Deallocate page if true */
sl@0	6221	){
sl@0	6222	MemPage *pPage = 0;
sl@0	6223	int rc;
sl@0	6224	unsigned char *pCell;
sl@0	6225	int i;
sl@0	6226
sl@0	6227	assert( sqlite3_mutex_held(pBt->mutex) );
sl@0	6228	if( pgno>pagerPagecount(pBt->pPager) ){
sl@0	6229	return SQLITE_CORRUPT_BKPT;
sl@0	6230	}
sl@0	6231
sl@0	6232	rc = getAndInitPage(pBt, pgno, &pPage);
sl@0	6233	if( rc ) goto cleardatabasepage_out;
sl@0	6234	for(i=0; i<pPage->nCell; i++){
sl@0	6235	pCell = findCell(pPage, i);
sl@0	6236	if( !pPage->leaf ){
sl@0	6237	rc = clearDatabasePage(pBt, get4byte(pCell), pPage, 1);
sl@0	6238	if( rc ) goto cleardatabasepage_out;
sl@0	6239	}
sl@0	6240	rc = clearCell(pPage, pCell);
sl@0	6241	if( rc ) goto cleardatabasepage_out;
sl@0	6242	}
sl@0	6243	if( !pPage->leaf ){
sl@0	6244	rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), pPage, 1);
sl@0	6245	if( rc ) goto cleardatabasepage_out;
sl@0	6246	}
sl@0	6247	if( freePageFlag ){
sl@0	6248	rc = freePage(pPage);
sl@0	6249	}else if( (rc = sqlite3PagerWrite(pPage->pDbPage))==0 ){
sl@0	6250	zeroPage(pPage, pPage->aData[0] \| PTF_LEAF);
sl@0	6251	}
sl@0	6252
sl@0	6253	cleardatabasepage_out:
sl@0	6254	releasePage(pPage);
sl@0	6255	return rc;
sl@0	6256	}
sl@0	6257
sl@0	6258	/*
sl@0	6259	** Delete all information from a single table in the database. iTable is
sl@0	6260	** the page number of the root of the table. After this routine returns,
sl@0	6261	** the root page is empty, but still exists.
sl@0	6262	**
sl@0	6263	** This routine will fail with SQLITE_LOCKED if there are any open
sl@0	6264	** read cursors on the table. Open write cursors are moved to the
sl@0	6265	** root of the table.
sl@0	6266	*/
sl@0	6267	int sqlite3BtreeClearTable(Btree *p, int iTable){
sl@0	6268	int rc;
sl@0	6269	BtShared *pBt = p->pBt;
sl@0	6270	sqlite3BtreeEnter(p);
sl@0	6271	pBt->db = p->db;
sl@0	6272	if( p->inTrans!=TRANS_WRITE ){
sl@0	6273	rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	6274	}else if( (rc = checkReadLocks(p, iTable, 0, 1))!=SQLITE_OK ){
sl@0	6275	/* nothing to do */
sl@0	6276	}else if( SQLITE_OK!=(rc = saveAllCursors(pBt, iTable, 0)) ){
sl@0	6277	/* nothing to do */
sl@0	6278	}else{
sl@0	6279	rc = clearDatabasePage(pBt, (Pgno)iTable, 0, 0);
sl@0	6280	}
sl@0	6281	sqlite3BtreeLeave(p);
sl@0	6282	return rc;
sl@0	6283	}
sl@0	6284
sl@0	6285	/*
sl@0	6286	** Erase all information in a table and add the root of the table to
sl@0	6287	** the freelist. Except, the root of the principle table (the one on
sl@0	6288	** page 1) is never added to the freelist.
sl@0	6289	**
sl@0	6290	** This routine will fail with SQLITE_LOCKED if there are any open
sl@0	6291	** cursors on the table.
sl@0	6292	**
sl@0	6293	** If AUTOVACUUM is enabled and the page at iTable is not the last
sl@0	6294	** root page in the database file, then the last root page
sl@0	6295	** in the database file is moved into the slot formerly occupied by
sl@0	6296	** iTable and that last slot formerly occupied by the last root page
sl@0	6297	** is added to the freelist instead of iTable. In this say, all
sl@0	6298	** root pages are kept at the beginning of the database file, which
sl@0	6299	** is necessary for AUTOVACUUM to work right. *piMoved is set to the
sl@0	6300	** page number that used to be the last root page in the file before
sl@0	6301	** the move. If no page gets moved, *piMoved is set to 0.
sl@0	6302	** The last root page is recorded in meta[3] and the value of
sl@0	6303	** meta[3] is updated by this procedure.
sl@0	6304	*/
sl@0	6305	static int btreeDropTable(Btree p, int iTable, int piMoved){
sl@0	6306	int rc;
sl@0	6307	MemPage *pPage = 0;
sl@0	6308	BtShared *pBt = p->pBt;
sl@0	6309
sl@0	6310	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	6311	if( p->inTrans!=TRANS_WRITE ){
sl@0	6312	return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	6313	}
sl@0	6314
sl@0	6315	/* It is illegal to drop a table if any cursors are open on the
sl@0	6316	** database. This is because in auto-vacuum mode the backend may
sl@0	6317	** need to move another root-page to fill a gap left by the deleted
sl@0	6318	** root page. If an open cursor was using this page a problem would
sl@0	6319	** occur.
sl@0	6320	*/
sl@0	6321	if( pBt->pCursor ){
sl@0	6322	return SQLITE_LOCKED;
sl@0	6323	}
sl@0	6324
sl@0	6325	rc = sqlite3BtreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
sl@0	6326	if( rc ) return rc;
sl@0	6327	rc = sqlite3BtreeClearTable(p, iTable);
sl@0	6328	if( rc ){
sl@0	6329	releasePage(pPage);
sl@0	6330	return rc;
sl@0	6331	}
sl@0	6332
sl@0	6333	*piMoved = 0;
sl@0	6334
sl@0	6335	if( iTable>1 ){
sl@0	6336	#ifdef SQLITE_OMIT_AUTOVACUUM
sl@0	6337	rc = freePage(pPage);
sl@0	6338	releasePage(pPage);
sl@0	6339	#else
sl@0	6340	if( pBt->autoVacuum ){
sl@0	6341	Pgno maxRootPgno;
sl@0	6342	rc = sqlite3BtreeGetMeta(p, 4, &maxRootPgno);
sl@0	6343	if( rc!=SQLITE_OK ){
sl@0	6344	releasePage(pPage);
sl@0	6345	return rc;
sl@0	6346	}
sl@0	6347
sl@0	6348	if( iTable==maxRootPgno ){
sl@0	6349	/* If the table being dropped is the table with the largest root-page
sl@0	6350	** number in the database, put the root page on the free list.
sl@0	6351	*/
sl@0	6352	rc = freePage(pPage);
sl@0	6353	releasePage(pPage);
sl@0	6354	if( rc!=SQLITE_OK ){
sl@0	6355	return rc;
sl@0	6356	}
sl@0	6357	}else{
sl@0	6358	/* The table being dropped does not have the largest root-page
sl@0	6359	** number in the database. So move the page that does into the
sl@0	6360	** gap left by the deleted root-page.
sl@0	6361	*/
sl@0	6362	MemPage *pMove;
sl@0	6363	releasePage(pPage);
sl@0	6364	rc = sqlite3BtreeGetPage(pBt, maxRootPgno, &pMove, 0);
sl@0	6365	if( rc!=SQLITE_OK ){
sl@0	6366	return rc;
sl@0	6367	}
sl@0	6368	rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
sl@0	6369	releasePage(pMove);
sl@0	6370	if( rc!=SQLITE_OK ){
sl@0	6371	return rc;
sl@0	6372	}
sl@0	6373	rc = sqlite3BtreeGetPage(pBt, maxRootPgno, &pMove, 0);
sl@0	6374	if( rc!=SQLITE_OK ){
sl@0	6375	return rc;
sl@0	6376	}
sl@0	6377	rc = freePage(pMove);
sl@0	6378	releasePage(pMove);
sl@0	6379	if( rc!=SQLITE_OK ){
sl@0	6380	return rc;
sl@0	6381	}
sl@0	6382	*piMoved = maxRootPgno;
sl@0	6383	}
sl@0	6384
sl@0	6385	/* Set the new 'max-root-page' value in the database header. This
sl@0	6386	** is the old value less one, less one more if that happens to
sl@0	6387	** be a root-page number, less one again if that is the
sl@0	6388	** PENDING_BYTE_PAGE.
sl@0	6389	*/
sl@0	6390	maxRootPgno--;
sl@0	6391	if( maxRootPgno==PENDING_BYTE_PAGE(pBt) ){
sl@0	6392	maxRootPgno--;
sl@0	6393	}
sl@0	6394	if( maxRootPgno==PTRMAP_PAGENO(pBt, maxRootPgno) ){
sl@0	6395	maxRootPgno--;
sl@0	6396	}
sl@0	6397	assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
sl@0	6398
sl@0	6399	rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
sl@0	6400	}else{
sl@0	6401	rc = freePage(pPage);
sl@0	6402	releasePage(pPage);
sl@0	6403	}
sl@0	6404	#endif
sl@0	6405	}else{
sl@0	6406	/* If sqlite3BtreeDropTable was called on page 1. */
sl@0	6407	zeroPage(pPage, PTF_INTKEY\|PTF_LEAF );
sl@0	6408	releasePage(pPage);
sl@0	6409	}
sl@0	6410	return rc;
sl@0	6411	}
sl@0	6412	int sqlite3BtreeDropTable(Btree p, int iTable, int piMoved){
sl@0	6413	int rc;
sl@0	6414	sqlite3BtreeEnter(p);
sl@0	6415	p->pBt->db = p->db;
sl@0	6416	rc = btreeDropTable(p, iTable, piMoved);
sl@0	6417	sqlite3BtreeLeave(p);
sl@0	6418	return rc;
sl@0	6419	}
sl@0	6420
sl@0	6421
sl@0	6422	/*
sl@0	6423	** Read the meta-information out of a database file. Meta[0]
sl@0	6424	** is the number of free pages currently in the database. Meta[1]
sl@0	6425	** through meta[15] are available for use by higher layers. Meta[0]
sl@0	6426	** is read-only, the others are read/write.
sl@0	6427	**
sl@0	6428	** The schema layer numbers meta values differently. At the schema
sl@0	6429	** layer (and the SetCookie and ReadCookie opcodes) the number of
sl@0	6430	** free pages is not visible. So Cookie[0] is the same as Meta[1].
sl@0	6431	*/
sl@0	6432	int sqlite3BtreeGetMeta(Btree p, int idx, u32 pMeta){
sl@0	6433	DbPage *pDbPage;
sl@0	6434	int rc;
sl@0	6435	unsigned char *pP1;
sl@0	6436	BtShared *pBt = p->pBt;
sl@0	6437
sl@0	6438	sqlite3BtreeEnter(p);
sl@0	6439	pBt->db = p->db;
sl@0	6440
sl@0	6441	/* Reading a meta-data value requires a read-lock on page 1 (and hence
sl@0	6442	** the sqlite_master table. We grab this lock regardless of whether or
sl@0	6443	** not the SQLITE_ReadUncommitted flag is set (the table rooted at page
sl@0	6444	** 1 is treated as a special case by queryTableLock() and lockTable()).
sl@0	6445	*/
sl@0	6446	rc = queryTableLock(p, 1, READ_LOCK);
sl@0	6447	if( rc!=SQLITE_OK ){
sl@0	6448	sqlite3BtreeLeave(p);
sl@0	6449	return rc;
sl@0	6450	}
sl@0	6451
sl@0	6452	assert( idx>=0 && idx<=15 );
sl@0	6453	if( pBt->pPage1 ){
sl@0	6454	/* The b-tree is already holding a reference to page 1 of the database
sl@0	6455	** file. In this case the required meta-data value can be read directly
sl@0	6456	** from the page data of this reference. This is slightly faster than
sl@0	6457	** requesting a new reference from the pager layer.
sl@0	6458	*/
sl@0	6459	pP1 = (unsigned char *)pBt->pPage1->aData;
sl@0	6460	}else{
sl@0	6461	/* The b-tree does not have a reference to page 1 of the database file.
sl@0	6462	** Obtain one from the pager layer.
sl@0	6463	*/
sl@0	6464	rc = sqlite3PagerGet(pBt->pPager, 1, &pDbPage);
sl@0	6465	if( rc ){
sl@0	6466	sqlite3BtreeLeave(p);
sl@0	6467	return rc;
sl@0	6468	}
sl@0	6469	pP1 = (unsigned char *)sqlite3PagerGetData(pDbPage);
sl@0	6470	}
sl@0	6471	pMeta = get4byte(&pP1[36 + idx4]);
sl@0	6472
sl@0	6473	/* If the b-tree is not holding a reference to page 1, then one was
sl@0	6474	** requested from the pager layer in the above block. Release it now.
sl@0	6475	*/
sl@0	6476	if( !pBt->pPage1 ){
sl@0	6477	sqlite3PagerUnref(pDbPage);
sl@0	6478	}
sl@0	6479
sl@0	6480	/* If autovacuumed is disabled in this build but we are trying to
sl@0	6481	** access an autovacuumed database, then make the database readonly.
sl@0	6482	*/
sl@0	6483	#ifdef SQLITE_OMIT_AUTOVACUUM
sl@0	6484	if( idx==4 && *pMeta>0 ) pBt->readOnly = 1;
sl@0	6485	#endif
sl@0	6486
sl@0	6487	/* Grab the read-lock on page 1. */
sl@0	6488	rc = lockTable(p, 1, READ_LOCK);
sl@0	6489	sqlite3BtreeLeave(p);
sl@0	6490	return rc;
sl@0	6491	}
sl@0	6492
sl@0	6493	/*
sl@0	6494	** Write meta-information back into the database. Meta[0] is
sl@0	6495	** read-only and may not be written.
sl@0	6496	*/
sl@0	6497	int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
sl@0	6498	BtShared *pBt = p->pBt;
sl@0	6499	unsigned char *pP1;
sl@0	6500	int rc;
sl@0	6501	assert( idx>=1 && idx<=15 );
sl@0	6502	sqlite3BtreeEnter(p);
sl@0	6503	pBt->db = p->db;
sl@0	6504	if( p->inTrans!=TRANS_WRITE ){
sl@0	6505	rc = pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
sl@0	6506	}else{
sl@0	6507	assert( pBt->pPage1!=0 );
sl@0	6508	pP1 = pBt->pPage1->aData;
sl@0	6509	rc = sqlite3PagerWrite(pBt->pPage1->pDbPage);
sl@0	6510	if( rc==SQLITE_OK ){
sl@0	6511	put4byte(&pP1[36 + idx*4], iMeta);
sl@0	6512	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6513	if( idx==7 ){
sl@0	6514	assert( pBt->autoVacuum \|\| iMeta==0 );
sl@0	6515	assert( iMeta==0 \|\| iMeta==1 );
sl@0	6516	pBt->incrVacuum = iMeta;
sl@0	6517	}
sl@0	6518	#endif
sl@0	6519	}
sl@0	6520	}
sl@0	6521	sqlite3BtreeLeave(p);
sl@0	6522	return rc;
sl@0	6523	}
sl@0	6524
sl@0	6525	/*
sl@0	6526	** Return the flag byte at the beginning of the page that the cursor
sl@0	6527	** is currently pointing to.
sl@0	6528	*/
sl@0	6529	int sqlite3BtreeFlags(BtCursor *pCur){
sl@0	6530	/* TODO: What about CURSOR_REQUIRESEEK state? Probably need to call
sl@0	6531	** restoreCursorPosition() here.
sl@0	6532	*/
sl@0	6533	MemPage *pPage;
sl@0	6534	restoreCursorPosition(pCur);
sl@0	6535	pPage = pCur->apPage[pCur->iPage];
sl@0	6536	assert( cursorHoldsMutex(pCur) );
sl@0	6537	assert( pPage->pBt==pCur->pBt );
sl@0	6538	return pPage ? pPage->aData[pPage->hdrOffset] : 0;
sl@0	6539	}
sl@0	6540
sl@0	6541
sl@0	6542	/*
sl@0	6543	** Return the pager associated with a BTree. This routine is used for
sl@0	6544	** testing and debugging only.
sl@0	6545	*/
sl@0	6546	Pager sqlite3BtreePager(Btree p){
sl@0	6547	return p->pBt->pPager;
sl@0	6548	}
sl@0	6549
sl@0	6550	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
sl@0	6551	/*
sl@0	6552	** Append a message to the error message string.
sl@0	6553	*/
sl@0	6554	static void checkAppendMsg(
sl@0	6555	IntegrityCk *pCheck,
sl@0	6556	char *zMsg1,
sl@0	6557	const char *zFormat,
sl@0	6558	...
sl@0	6559	){
sl@0	6560	va_list ap;
sl@0	6561	if( !pCheck->mxErr ) return;
sl@0	6562	pCheck->mxErr--;
sl@0	6563	pCheck->nErr++;
sl@0	6564	va_start(ap, zFormat);
sl@0	6565	if( pCheck->errMsg.nChar ){
sl@0	6566	sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
sl@0	6567	}
sl@0	6568	if( zMsg1 ){
sl@0	6569	sqlite3StrAccumAppend(&pCheck->errMsg, zMsg1, -1);
sl@0	6570	}
sl@0	6571	sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
sl@0	6572	va_end(ap);
sl@0	6573	if( pCheck->errMsg.mallocFailed ){
sl@0	6574	pCheck->mallocFailed = 1;
sl@0	6575	}
sl@0	6576	}
sl@0	6577	#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
sl@0	6578
sl@0	6579	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
sl@0	6580	/*
sl@0	6581	** Add 1 to the reference count for page iPage. If this is the second
sl@0	6582	** reference to the page, add an error message to pCheck->zErrMsg.
sl@0	6583	** Return 1 if there are 2 ore more references to the page and 0 if
sl@0	6584	** if this is the first reference to the page.
sl@0	6585	**
sl@0	6586	** Also check that the page number is in bounds.
sl@0	6587	*/
sl@0	6588	static int checkRef(IntegrityCk pCheck, int iPage, char zContext){
sl@0	6589	if( iPage==0 ) return 1;
sl@0	6590	if( iPage>pCheck->nPage \|\| iPage<0 ){
sl@0	6591	checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
sl@0	6592	return 1;
sl@0	6593	}
sl@0	6594	if( pCheck->anRef[iPage]==1 ){
sl@0	6595	checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
sl@0	6596	return 1;
sl@0	6597	}
sl@0	6598	return (pCheck->anRef[iPage]++)>1;
sl@0	6599	}
sl@0	6600
sl@0	6601	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6602	/*
sl@0	6603	** Check that the entry in the pointer-map for page iChild maps to
sl@0	6604	** page iParent, pointer type ptrType. If not, append an error message
sl@0	6605	** to pCheck.
sl@0	6606	*/
sl@0	6607	static void checkPtrmap(
sl@0	6608	IntegrityCk pCheck, / Integrity check context */
sl@0	6609	Pgno iChild, /* Child page number */
sl@0	6610	u8 eType, /* Expected pointer map type */
sl@0	6611	Pgno iParent, /* Expected pointer map parent page number */
sl@0	6612	char zContext / Context description (used for error msg) */
sl@0	6613	){
sl@0	6614	int rc;
sl@0	6615	u8 ePtrmapType;
sl@0	6616	Pgno iPtrmapParent;
sl@0	6617
sl@0	6618	rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
sl@0	6619	if( rc!=SQLITE_OK ){
sl@0	6620	checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
sl@0	6621	return;
sl@0	6622	}
sl@0	6623
sl@0	6624	if( ePtrmapType!=eType \|\| iPtrmapParent!=iParent ){
sl@0	6625	checkAppendMsg(pCheck, zContext,
sl@0	6626	"Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)",
sl@0	6627	iChild, eType, iParent, ePtrmapType, iPtrmapParent);
sl@0	6628	}
sl@0	6629	}
sl@0	6630	#endif
sl@0	6631
sl@0	6632	/*
sl@0	6633	** Check the integrity of the freelist or of an overflow page list.
sl@0	6634	** Verify that the number of pages on the list is N.
sl@0	6635	*/
sl@0	6636	static void checkList(
sl@0	6637	IntegrityCk pCheck, / Integrity checking context */
sl@0	6638	int isFreeList, /* True for a freelist. False for overflow page list */
sl@0	6639	int iPage, /* Page number for first page in the list */
sl@0	6640	int N, /* Expected number of pages in the list */
sl@0	6641	char zContext / Context for error messages */
sl@0	6642	){
sl@0	6643	int i;
sl@0	6644	int expected = N;
sl@0	6645	int iFirst = iPage;
sl@0	6646	while( N-- > 0 && pCheck->mxErr ){
sl@0	6647	DbPage *pOvflPage;
sl@0	6648	unsigned char *pOvflData;
sl@0	6649	if( iPage<1 ){
sl@0	6650	checkAppendMsg(pCheck, zContext,
sl@0	6651	"%d of %d pages missing from overflow list starting at %d",
sl@0	6652	N+1, expected, iFirst);
sl@0	6653	break;
sl@0	6654	}
sl@0	6655	if( checkRef(pCheck, iPage, zContext) ) break;
sl@0	6656	if( sqlite3PagerGet(pCheck->pPager, (Pgno)iPage, &pOvflPage) ){
sl@0	6657	checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
sl@0	6658	break;
sl@0	6659	}
sl@0	6660	pOvflData = (unsigned char *)sqlite3PagerGetData(pOvflPage);
sl@0	6661	if( isFreeList ){
sl@0	6662	int n = get4byte(&pOvflData[4]);
sl@0	6663	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6664	if( pCheck->pBt->autoVacuum ){
sl@0	6665	checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
sl@0	6666	}
sl@0	6667	#endif
sl@0	6668	if( n>pCheck->pBt->usableSize/4-2 ){
sl@0	6669	checkAppendMsg(pCheck, zContext,
sl@0	6670	"freelist leaf count too big on page %d", iPage);
sl@0	6671	N--;
sl@0	6672	}else{
sl@0	6673	for(i=0; i<n; i++){
sl@0	6674	Pgno iFreePage = get4byte(&pOvflData[8+i*4]);
sl@0	6675	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6676	if( pCheck->pBt->autoVacuum ){
sl@0	6677	checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
sl@0	6678	}
sl@0	6679	#endif
sl@0	6680	checkRef(pCheck, iFreePage, zContext);
sl@0	6681	}
sl@0	6682	N -= n;
sl@0	6683	}
sl@0	6684	}
sl@0	6685	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6686	else{
sl@0	6687	/* If this database supports auto-vacuum and iPage is not the last
sl@0	6688	** page in this overflow list, check that the pointer-map entry for
sl@0	6689	** the following page matches iPage.
sl@0	6690	*/
sl@0	6691	if( pCheck->pBt->autoVacuum && N>0 ){
sl@0	6692	i = get4byte(pOvflData);
sl@0	6693	checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
sl@0	6694	}
sl@0	6695	}
sl@0	6696	#endif
sl@0	6697	iPage = get4byte(pOvflData);
sl@0	6698	sqlite3PagerUnref(pOvflPage);
sl@0	6699	}
sl@0	6700	}
sl@0	6701	#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
sl@0	6702
sl@0	6703	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
sl@0	6704	/*
sl@0	6705	** Do various sanity checks on a single page of a tree. Return
sl@0	6706	** the tree depth. Root pages return 0. Parents of root pages
sl@0	6707	** return 1, and so forth.
sl@0	6708	**
sl@0	6709	** These checks are done:
sl@0	6710	**
sl@0	6711	** 1. Make sure that cells and freeblocks do not overlap
sl@0	6712	** but combine to completely cover the page.
sl@0	6713	** NO 2. Make sure cell keys are in order.
sl@0	6714	** NO 3. Make sure no key is less than or equal to zLowerBound.
sl@0	6715	** NO 4. Make sure no key is greater than or equal to zUpperBound.
sl@0	6716	** 5. Check the integrity of overflow pages.
sl@0	6717	** 6. Recursively call checkTreePage on all children.
sl@0	6718	** 7. Verify that the depth of all children is the same.
sl@0	6719	** 8. Make sure this page is at least 33% full or else it is
sl@0	6720	** the root of the tree.
sl@0	6721	*/
sl@0	6722	static int checkTreePage(
sl@0	6723	IntegrityCk pCheck, / Context for the sanity check */
sl@0	6724	int iPage, /* Page number of the page to check */
sl@0	6725	MemPage pParent, / Parent page */
sl@0	6726	char zParentContext / Parent context */
sl@0	6727	){
sl@0	6728	MemPage *pPage;
sl@0	6729	int i, rc, depth, d2, pgno, cnt;
sl@0	6730	int hdr, cellStart;
sl@0	6731	int nCell;
sl@0	6732	u8 *data;
sl@0	6733	BtShared *pBt;
sl@0	6734	int usableSize;
sl@0	6735	char zContext[100];
sl@0	6736	char *hit = 0;
sl@0	6737
sl@0	6738	sqlite3_snprintf(sizeof(zContext), zContext, "Page %d: ", iPage);
sl@0	6739
sl@0	6740	/* Check that the page exists
sl@0	6741	*/
sl@0	6742	pBt = pCheck->pBt;
sl@0	6743	usableSize = pBt->usableSize;
sl@0	6744	if( iPage==0 ) return 0;
sl@0	6745	if( checkRef(pCheck, iPage, zParentContext) ) return 0;
sl@0	6746	if( (rc = sqlite3BtreeGetPage(pBt, (Pgno)iPage, &pPage, 0))!=0 ){
sl@0	6747	checkAppendMsg(pCheck, zContext,
sl@0	6748	"unable to get the page. error code=%d", rc);
sl@0	6749	return 0;
sl@0	6750	}
sl@0	6751	if( (rc = sqlite3BtreeInitPage(pPage))!=0 ){
sl@0	6752	checkAppendMsg(pCheck, zContext,
sl@0	6753	"sqlite3BtreeInitPage() returns error code %d", rc);
sl@0	6754	releasePage(pPage);
sl@0	6755	return 0;
sl@0	6756	}
sl@0	6757
sl@0	6758	/* Check out all the cells.
sl@0	6759	*/
sl@0	6760	depth = 0;
sl@0	6761	for(i=0; i<pPage->nCell && pCheck->mxErr; i++){
sl@0	6762	u8 *pCell;
sl@0	6763	int sz;
sl@0	6764	CellInfo info;
sl@0	6765
sl@0	6766	/* Check payload overflow pages
sl@0	6767	*/
sl@0	6768	sqlite3_snprintf(sizeof(zContext), zContext,
sl@0	6769	"On tree page %d cell %d: ", iPage, i);
sl@0	6770	pCell = findCell(pPage,i);
sl@0	6771	sqlite3BtreeParseCellPtr(pPage, pCell, &info);
sl@0	6772	sz = info.nData;
sl@0	6773	if( !pPage->intKey ) sz += info.nKey;
sl@0	6774	assert( sz==info.nPayload );
sl@0	6775	if( sz>info.nLocal ){
sl@0	6776	int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
sl@0	6777	Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
sl@0	6778	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6779	if( pBt->autoVacuum ){
sl@0	6780	checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
sl@0	6781	}
sl@0	6782	#endif
sl@0	6783	checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
sl@0	6784	}
sl@0	6785
sl@0	6786	/* Check sanity of left child page.
sl@0	6787	*/
sl@0	6788	if( !pPage->leaf ){
sl@0	6789	pgno = get4byte(pCell);
sl@0	6790	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6791	if( pBt->autoVacuum ){
sl@0	6792	checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
sl@0	6793	}
sl@0	6794	#endif
sl@0	6795	d2 = checkTreePage(pCheck,pgno,pPage,zContext);
sl@0	6796	if( i>0 && d2!=depth ){
sl@0	6797	checkAppendMsg(pCheck, zContext, "Child page depth differs");
sl@0	6798	}
sl@0	6799	depth = d2;
sl@0	6800	}
sl@0	6801	}
sl@0	6802	if( !pPage->leaf ){
sl@0	6803	pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
sl@0	6804	sqlite3_snprintf(sizeof(zContext), zContext,
sl@0	6805	"On page %d at right child: ", iPage);
sl@0	6806	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6807	if( pBt->autoVacuum ){
sl@0	6808	checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, 0);
sl@0	6809	}
sl@0	6810	#endif
sl@0	6811	checkTreePage(pCheck, pgno, pPage, zContext);
sl@0	6812	}
sl@0	6813
sl@0	6814	/* Check for complete coverage of the page
sl@0	6815	*/
sl@0	6816	data = pPage->aData;
sl@0	6817	hdr = pPage->hdrOffset;
sl@0	6818	hit = sqlite3PageMalloc( pBt->pageSize );
sl@0	6819	if( hit==0 ){
sl@0	6820	pCheck->mallocFailed = 1;
sl@0	6821	}else{
sl@0	6822	u16 contentOffset = get2byte(&data[hdr+5]);
sl@0	6823	if (contentOffset > usableSize) {
sl@0	6824	checkAppendMsg(pCheck, 0,
sl@0	6825	"Corruption detected in header on page %d",iPage,0);
sl@0	6826	goto check_page_abort;
sl@0	6827	}
sl@0	6828	memset(hit, 0, usableSize );
sl@0	6829	memset(hit, 1, get2byte(&data[hdr+5]));
sl@0	6830	nCell = get2byte(&data[hdr+3]);
sl@0	6831	cellStart = hdr + 12 - 4*pPage->leaf;
sl@0	6832	for(i=0; i<nCell; i++){
sl@0	6833	int pc = get2byte(&data[cellStart+i*2]);
sl@0	6834	u16 size = 1024;
sl@0	6835	int j;
sl@0	6836	if( pc<=usableSize ){
sl@0	6837	size = cellSizePtr(pPage, &data[pc]);
sl@0	6838	}
sl@0	6839	if( (pc+size-1)>=usableSize \|\| pc<0 ){
sl@0	6840	checkAppendMsg(pCheck, 0,
sl@0	6841	"Corruption detected in cell %d on page %d",i,iPage,0);
sl@0	6842	}else{
sl@0	6843	for(j=pc+size-1; j>=pc; j--) hit[j]++;
sl@0	6844	}
sl@0	6845	}
sl@0	6846	for(cnt=0, i=get2byte(&data[hdr+1]); i>0 && i<usableSize && cnt<10000;
sl@0	6847	cnt++){
sl@0	6848	int size = get2byte(&data[i+2]);
sl@0	6849	int j;
sl@0	6850	if( (i+size-1)>=usableSize \|\| i<0 ){
sl@0	6851	checkAppendMsg(pCheck, 0,
sl@0	6852	"Corruption detected in cell %d on page %d",i,iPage,0);
sl@0	6853	}else{
sl@0	6854	for(j=i+size-1; j>=i; j--) hit[j]++;
sl@0	6855	}
sl@0	6856	i = get2byte(&data[i]);
sl@0	6857	}
sl@0	6858	for(i=cnt=0; i<usableSize; i++){
sl@0	6859	if( hit[i]==0 ){
sl@0	6860	cnt++;
sl@0	6861	}else if( hit[i]>1 ){
sl@0	6862	checkAppendMsg(pCheck, 0,
sl@0	6863	"Multiple uses for byte %d of page %d", i, iPage);
sl@0	6864	break;
sl@0	6865	}
sl@0	6866	}
sl@0	6867	if( cnt!=data[hdr+7] ){
sl@0	6868	checkAppendMsg(pCheck, 0,
sl@0	6869	"Fragmented space is %d byte reported as %d on page %d",
sl@0	6870	cnt, data[hdr+7], iPage);
sl@0	6871	}
sl@0	6872	}
sl@0	6873
sl@0	6874	check_page_abort:
sl@0	6875	if( hit ) sqlite3PageFree(hit);
sl@0	6876
sl@0	6877	releasePage(pPage);
sl@0	6878	return depth+1;
sl@0	6879	}
sl@0	6880	#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
sl@0	6881
sl@0	6882	#ifndef SQLITE_OMIT_INTEGRITY_CHECK
sl@0	6883	/*
sl@0	6884	** This routine does a complete check of the given BTree file. aRoot[] is
sl@0	6885	** an array of pages numbers were each page number is the root page of
sl@0	6886	** a table. nRoot is the number of entries in aRoot.
sl@0	6887	**
sl@0	6888	** Write the number of error seen in *pnErr. Except for some memory
sl@0	6889	** allocation errors, nn error message is held in memory obtained from
sl@0	6890	** malloc is returned if pnErr is non-zero. If pnErr==0 then NULL is
sl@0	6891	** returned.
sl@0	6892	*/
sl@0	6893	char *sqlite3BtreeIntegrityCheck(
sl@0	6894	Btree p, / The btree to be checked */
sl@0	6895	int aRoot, / An array of root pages numbers for individual trees */
sl@0	6896	int nRoot, /* Number of entries in aRoot[] */
sl@0	6897	int mxErr, /* Stop reporting errors after this many */
sl@0	6898	int pnErr / Write number of errors seen to this variable */
sl@0	6899	){
sl@0	6900	int i;
sl@0	6901	int nRef;
sl@0	6902	IntegrityCk sCheck;
sl@0	6903	BtShared *pBt = p->pBt;
sl@0	6904	char zErr[100];
sl@0	6905
sl@0	6906	sqlite3BtreeEnter(p);
sl@0	6907	pBt->db = p->db;
sl@0	6908	nRef = sqlite3PagerRefcount(pBt->pPager);
sl@0	6909	if( lockBtreeWithRetry(p)!=SQLITE_OK ){
sl@0	6910	*pnErr = 1;
sl@0	6911	sqlite3BtreeLeave(p);
sl@0	6912	return sqlite3DbStrDup(0, "cannot acquire a read lock on the database");
sl@0	6913	}
sl@0	6914	sCheck.pBt = pBt;
sl@0	6915	sCheck.pPager = pBt->pPager;
sl@0	6916	sCheck.nPage = pagerPagecount(sCheck.pPager);
sl@0	6917	sCheck.mxErr = mxErr;
sl@0	6918	sCheck.nErr = 0;
sl@0	6919	sCheck.mallocFailed = 0;
sl@0	6920	*pnErr = 0;
sl@0	6921	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6922	if( pBt->nTrunc!=0 ){
sl@0	6923	sCheck.nPage = pBt->nTrunc;
sl@0	6924	}
sl@0	6925	#endif
sl@0	6926	if( sCheck.nPage==0 ){
sl@0	6927	unlockBtreeIfUnused(pBt);
sl@0	6928	sqlite3BtreeLeave(p);
sl@0	6929	return 0;
sl@0	6930	}
sl@0	6931	sCheck.anRef = sqlite3Malloc( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
sl@0	6932	if( !sCheck.anRef ){
sl@0	6933	unlockBtreeIfUnused(pBt);
sl@0	6934	*pnErr = 1;
sl@0	6935	sqlite3BtreeLeave(p);
sl@0	6936	return 0;
sl@0	6937	}
sl@0	6938	for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
sl@0	6939	i = PENDING_BYTE_PAGE(pBt);
sl@0	6940	if( i<=sCheck.nPage ){
sl@0	6941	sCheck.anRef[i] = 1;
sl@0	6942	}
sl@0	6943	sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000);
sl@0	6944
sl@0	6945	/* Check the integrity of the freelist
sl@0	6946	*/
sl@0	6947	checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
sl@0	6948	get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
sl@0	6949
sl@0	6950	/* Check all the tables.
sl@0	6951	*/
sl@0	6952	for(i=0; i<nRoot && sCheck.mxErr; i++){
sl@0	6953	if( aRoot[i]==0 ) continue;
sl@0	6954	#ifndef SQLITE_OMIT_AUTOVACUUM
sl@0	6955	if( pBt->autoVacuum && aRoot[i]>1 ){
sl@0	6956	checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
sl@0	6957	}
sl@0	6958	#endif
sl@0	6959	checkTreePage(&sCheck, aRoot[i], 0, "List of tree roots: ");
sl@0	6960	}
sl@0	6961
sl@0	6962	/* Make sure every page in the file is referenced
sl@0	6963	*/
sl@0	6964	for(i=1; i<=sCheck.nPage && sCheck.mxErr; i++){
sl@0	6965	#ifdef SQLITE_OMIT_AUTOVACUUM
sl@0	6966	if( sCheck.anRef[i]==0 ){
sl@0	6967	checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
sl@0	6968	}
sl@0	6969	#else
sl@0	6970	/* If the database supports auto-vacuum, make sure no tables contain
sl@0	6971	** references to pointer-map pages.
sl@0	6972	*/
sl@0	6973	if( sCheck.anRef[i]==0 &&
sl@0	6974	(PTRMAP_PAGENO(pBt, i)!=i \|\| !pBt->autoVacuum) ){
sl@0	6975	checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
sl@0	6976	}
sl@0	6977	if( sCheck.anRef[i]!=0 &&
sl@0	6978	(PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
sl@0	6979	checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
sl@0	6980	}
sl@0	6981	#endif
sl@0	6982	}
sl@0	6983
sl@0	6984	/* Make sure this analysis did not leave any unref() pages
sl@0	6985	*/
sl@0	6986	unlockBtreeIfUnused(pBt);
sl@0	6987	if( nRef != sqlite3PagerRefcount(pBt->pPager) ){
sl@0	6988	checkAppendMsg(&sCheck, 0,
sl@0	6989	"Outstanding page count goes from %d to %d during this analysis",
sl@0	6990	nRef, sqlite3PagerRefcount(pBt->pPager)
sl@0	6991	);
sl@0	6992	}
sl@0	6993
sl@0	6994	/* Clean up and report errors.
sl@0	6995	*/
sl@0	6996	sqlite3BtreeLeave(p);
sl@0	6997	sqlite3_free(sCheck.anRef);
sl@0	6998	if( sCheck.mallocFailed ){
sl@0	6999	sqlite3StrAccumReset(&sCheck.errMsg);
sl@0	7000	*pnErr = sCheck.nErr+1;
sl@0	7001	return 0;
sl@0	7002	}
sl@0	7003	*pnErr = sCheck.nErr;
sl@0	7004	if( sCheck.nErr==0 ) sqlite3StrAccumReset(&sCheck.errMsg);
sl@0	7005	return sqlite3StrAccumFinish(&sCheck.errMsg);
sl@0	7006	}
sl@0	7007	#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
sl@0	7008
sl@0	7009	/*
sl@0	7010	** Return the full pathname of the underlying database file.
sl@0	7011	**
sl@0	7012	** The pager filename is invariant as long as the pager is
sl@0	7013	** open so it is safe to access without the BtShared mutex.
sl@0	7014	*/
sl@0	7015	const char sqlite3BtreeGetFilename(Btree p){
sl@0	7016	assert( p->pBt->pPager!=0 );
sl@0	7017	return sqlite3PagerFilename(p->pBt->pPager);
sl@0	7018	}
sl@0	7019
sl@0	7020	/*
sl@0	7021	** Return the pathname of the directory that contains the database file.
sl@0	7022	**
sl@0	7023	** The pager directory name is invariant as long as the pager is
sl@0	7024	** open so it is safe to access without the BtShared mutex.
sl@0	7025	*/
sl@0	7026	const char sqlite3BtreeGetDirname(Btree p){
sl@0	7027	assert( p->pBt->pPager!=0 );
sl@0	7028	return sqlite3PagerDirname(p->pBt->pPager);
sl@0	7029	}
sl@0	7030
sl@0	7031	/*
sl@0	7032	** Return the pathname of the journal file for this database. The return
sl@0	7033	** value of this routine is the same regardless of whether the journal file
sl@0	7034	** has been created or not.
sl@0	7035	**
sl@0	7036	** The pager journal filename is invariant as long as the pager is
sl@0	7037	** open so it is safe to access without the BtShared mutex.
sl@0	7038	*/
sl@0	7039	const char sqlite3BtreeGetJournalname(Btree p){
sl@0	7040	assert( p->pBt->pPager!=0 );
sl@0	7041	return sqlite3PagerJournalname(p->pBt->pPager);
sl@0	7042	}
sl@0	7043
sl@0	7044	#ifndef SQLITE_OMIT_VACUUM
sl@0	7045	/*
sl@0	7046	** Copy the complete content of pBtFrom into pBtTo. A transaction
sl@0	7047	** must be active for both files.
sl@0	7048	**
sl@0	7049	** The size of file pTo may be reduced by this operation.
sl@0	7050	** If anything goes wrong, the transaction on pTo is rolled back.
sl@0	7051	**
sl@0	7052	** If successful, CommitPhaseOne() may be called on pTo before returning.
sl@0	7053	** The caller should finish committing the transaction on pTo by calling
sl@0	7054	** sqlite3BtreeCommit().
sl@0	7055	*/
sl@0	7056	static int btreeCopyFile(Btree pTo, Btree pFrom){
sl@0	7057	int rc = SQLITE_OK;
sl@0	7058	Pgno i;
sl@0	7059
sl@0	7060	Pgno nFromPage; /* Number of pages in pFrom */
sl@0	7061	Pgno nToPage; /* Number of pages in pTo */
sl@0	7062	Pgno nNewPage; /* Number of pages in pTo after the copy */
sl@0	7063
sl@0	7064	Pgno iSkip; /* Pending byte page in pTo */
sl@0	7065	int nToPageSize; /* Page size of pTo in bytes */
sl@0	7066	int nFromPageSize; /* Page size of pFrom in bytes */
sl@0	7067
sl@0	7068	BtShared *pBtTo = pTo->pBt;
sl@0	7069	BtShared *pBtFrom = pFrom->pBt;
sl@0	7070	pBtTo->db = pTo->db;
sl@0	7071	pBtFrom->db = pFrom->db;
sl@0	7072
sl@0	7073	nToPageSize = pBtTo->pageSize;
sl@0	7074	nFromPageSize = pBtFrom->pageSize;
sl@0	7075
sl@0	7076	if( pTo->inTrans!=TRANS_WRITE \|\| pFrom->inTrans!=TRANS_WRITE ){
sl@0	7077	return SQLITE_ERROR;
sl@0	7078	}
sl@0	7079	if( pBtTo->pCursor ){
sl@0	7080	return SQLITE_BUSY;
sl@0	7081	}
sl@0	7082
sl@0	7083	nToPage = pagerPagecount(pBtTo->pPager);
sl@0	7084	nFromPage = pagerPagecount(pBtFrom->pPager);
sl@0	7085	iSkip = PENDING_BYTE_PAGE(pBtTo);
sl@0	7086
sl@0	7087	/* Variable nNewPage is the number of pages required to store the
sl@0	7088	** contents of pFrom using the current page-size of pTo.
sl@0	7089	*/
sl@0	7090	nNewPage = ((i64)nFromPage * (i64)nFromPageSize + (i64)nToPageSize - 1) /
sl@0	7091	(i64)nToPageSize;
sl@0	7092
sl@0	7093	for(i=1; rc==SQLITE_OK && (i<=nToPage \|\| i<=nNewPage); i++){
sl@0	7094
sl@0	7095	/* Journal the original page.
sl@0	7096	**
sl@0	7097	** iSkip is the page number of the locking page (PENDING_BYTE_PAGE)
sl@0	7098	** in database *pTo (before the copy). This page is never written
sl@0	7099	** into the journal file. Unless i==iSkip or the page was not
sl@0	7100	** present in pTo before the copy operation, journal page i from pTo.
sl@0	7101	*/
sl@0	7102	if( i!=iSkip && i<=nToPage ){
sl@0	7103	DbPage *pDbPage = 0;
sl@0	7104	rc = sqlite3PagerGet(pBtTo->pPager, i, &pDbPage);
sl@0	7105	if( rc==SQLITE_OK ){
sl@0	7106	rc = sqlite3PagerWrite(pDbPage);
sl@0	7107	if( rc==SQLITE_OK && i>nFromPage ){
sl@0	7108	/* Yeah. It seems wierd to call DontWrite() right after Write(). But
sl@0	7109	** that is because the names of those procedures do not exactly
sl@0	7110	** represent what they do. Write() really means "put this page in the
sl@0	7111	** rollback journal and mark it as dirty so that it will be written
sl@0	7112	** to the database file later." DontWrite() undoes the second part of
sl@0	7113	** that and prevents the page from being written to the database. The
sl@0	7114	** page is still on the rollback journal, though. And that is the
sl@0	7115	** whole point of this block: to put pages on the rollback journal.
sl@0	7116	*/
sl@0	7117	rc = sqlite3PagerDontWrite(pDbPage);
sl@0	7118	}
sl@0	7119	sqlite3PagerUnref(pDbPage);
sl@0	7120	}
sl@0	7121	}
sl@0	7122
sl@0	7123	/* Overwrite the data in page i of the target database */
sl@0	7124	if( rc==SQLITE_OK && i!=iSkip && i<=nNewPage ){
sl@0	7125
sl@0	7126	DbPage *pToPage = 0;
sl@0	7127	sqlite3_int64 iOff;
sl@0	7128
sl@0	7129	rc = sqlite3PagerGet(pBtTo->pPager, i, &pToPage);
sl@0	7130	if( rc==SQLITE_OK ){
sl@0	7131	rc = sqlite3PagerWrite(pToPage);
sl@0	7132	}
sl@0	7133
sl@0	7134	for(
sl@0	7135	iOff=(i-1)*nToPageSize;
sl@0	7136	rc==SQLITE_OK && iOff<i*nToPageSize;
sl@0	7137	iOff += nFromPageSize
sl@0	7138	){
sl@0	7139	DbPage *pFromPage = 0;
sl@0	7140	Pgno iFrom = (iOff/nFromPageSize)+1;
sl@0	7141
sl@0	7142	if( iFrom==PENDING_BYTE_PAGE(pBtFrom) ){
sl@0	7143	continue;
sl@0	7144	}
sl@0	7145
sl@0	7146	rc = sqlite3PagerGet(pBtFrom->pPager, iFrom, &pFromPage);
sl@0	7147	if( rc==SQLITE_OK ){
sl@0	7148	char *zTo = sqlite3PagerGetData(pToPage);
sl@0	7149	char *zFrom = sqlite3PagerGetData(pFromPage);
sl@0	7150	int nCopy;
sl@0	7151
sl@0	7152	if( nFromPageSize>=nToPageSize ){
sl@0	7153	zFrom += ((i-1)nToPageSize - ((iFrom-1)nFromPageSize));
sl@0	7154	nCopy = nToPageSize;
sl@0	7155	}else{
sl@0	7156	zTo += (((iFrom-1)nFromPageSize) - (i-1)nToPageSize);
sl@0	7157	nCopy = nFromPageSize;
sl@0	7158	}
sl@0	7159
sl@0	7160	memcpy(zTo, zFrom, nCopy);
sl@0	7161	sqlite3PagerUnref(pFromPage);
sl@0	7162	}
sl@0	7163	}
sl@0	7164
sl@0	7165	if( pToPage ){
sl@0	7166	MemPage p = (MemPage )sqlite3PagerGetExtra(pToPage);
sl@0	7167	p->isInit = 0;
sl@0	7168	sqlite3PagerUnref(pToPage);
sl@0	7169	}
sl@0	7170	}
sl@0	7171	}
sl@0	7172
sl@0	7173	/* If things have worked so far, the database file may need to be
sl@0	7174	** truncated. The complex part is that it may need to be truncated to
sl@0	7175	** a size that is not an integer multiple of nToPageSize - the current
sl@0	7176	** page size used by the pager associated with B-Tree pTo.
sl@0	7177	**
sl@0	7178	** For example, say the page-size of pTo is 2048 bytes and the original
sl@0	7179	** number of pages is 5 (10 KB file). If pFrom has a page size of 1024
sl@0	7180	** bytes and 9 pages, then the file needs to be truncated to 9KB.
sl@0	7181	*/
sl@0	7182	if( rc==SQLITE_OK ){
sl@0	7183	if( nFromPageSize!=nToPageSize ){
sl@0	7184	sqlite3_file *pFile = sqlite3PagerFile(pBtTo->pPager);
sl@0	7185	i64 iSize = (i64)nFromPageSize * (i64)nFromPage;
sl@0	7186	i64 iNow = (i64)((nToPage>nNewPage)?nToPage:nNewPage) * (i64)nToPageSize;
sl@0	7187	i64 iPending = ((i64)PENDING_BYTE_PAGE(pBtTo)-1) *(i64)nToPageSize;
sl@0	7188
sl@0	7189	assert( iSize<=iNow );
sl@0	7190
sl@0	7191	/* Commit phase one syncs the journal file associated with pTo
sl@0	7192	** containing the original data. It does not sync the database file
sl@0	7193	** itself. After doing this it is safe to use OsTruncate() and other
sl@0	7194	** file APIs on the database file directly.
sl@0	7195	*/
sl@0	7196	pBtTo->db = pTo->db;
sl@0	7197	rc = sqlite3PagerCommitPhaseOne(pBtTo->pPager, 0, 0, 1);
sl@0	7198	if( iSize<iNow && rc==SQLITE_OK ){
sl@0	7199	rc = sqlite3OsTruncate(pFile, iSize);
sl@0	7200	}
sl@0	7201
sl@0	7202	/* The loop that copied data from database pFrom to pTo did not
sl@0	7203	** populate the locking page of database pTo. If the page-size of
sl@0	7204	** pFrom is smaller than that of pTo, this means some data will
sl@0	7205	** not have been copied.
sl@0	7206	**
sl@0	7207	** This block copies the missing data from database pFrom to pTo
sl@0	7208	** using file APIs. This is safe because at this point we know that
sl@0	7209	** all of the original data from pTo has been synced into the
sl@0	7210	** journal file. At this point it would be safe to do anything at
sl@0	7211	** all to the database file except truncate it to zero bytes.
sl@0	7212	*/
sl@0	7213	if( rc==SQLITE_OK && nFromPageSize<nToPageSize && iSize>iPending){
sl@0	7214	i64 iOff;
sl@0	7215	for(
sl@0	7216	iOff=iPending;
sl@0	7217	rc==SQLITE_OK && iOff<(iPending+nToPageSize);
sl@0	7218	iOff += nFromPageSize
sl@0	7219	){
sl@0	7220	DbPage *pFromPage = 0;
sl@0	7221	Pgno iFrom = (iOff/nFromPageSize)+1;
sl@0	7222
sl@0	7223	if( iFrom==PENDING_BYTE_PAGE(pBtFrom) \|\| iFrom>nFromPage ){
sl@0	7224	continue;
sl@0	7225	}
sl@0	7226
sl@0	7227	rc = sqlite3PagerGet(pBtFrom->pPager, iFrom, &pFromPage);
sl@0	7228	if( rc==SQLITE_OK ){
sl@0	7229	char *zFrom = sqlite3PagerGetData(pFromPage);
sl@0	7230	rc = sqlite3OsWrite(pFile, zFrom, nFromPageSize, iOff);
sl@0	7231	sqlite3PagerUnref(pFromPage);
sl@0	7232	}
sl@0	7233	}
sl@0	7234	}
sl@0	7235
sl@0	7236	/* Sync the database file */
sl@0	7237	if( rc==SQLITE_OK ){
sl@0	7238	rc = sqlite3PagerSync(pBtTo->pPager);
sl@0	7239	}
sl@0	7240	}else{
sl@0	7241	rc = sqlite3PagerTruncate(pBtTo->pPager, nNewPage);
sl@0	7242	}
sl@0	7243	if( rc==SQLITE_OK ){
sl@0	7244	pBtTo->pageSizeFixed = 0;
sl@0	7245	}
sl@0	7246	}
sl@0	7247
sl@0	7248	if( rc ){
sl@0	7249	sqlite3BtreeRollback(pTo);
sl@0	7250	}
sl@0	7251
sl@0	7252	return rc;
sl@0	7253	}
sl@0	7254	int sqlite3BtreeCopyFile(Btree pTo, Btree pFrom){
sl@0	7255	int rc;
sl@0	7256	sqlite3BtreeEnter(pTo);
sl@0	7257	sqlite3BtreeEnter(pFrom);
sl@0	7258	rc = btreeCopyFile(pTo, pFrom);
sl@0	7259	sqlite3BtreeLeave(pFrom);
sl@0	7260	sqlite3BtreeLeave(pTo);
sl@0	7261	return rc;
sl@0	7262	}
sl@0	7263
sl@0	7264	#endif /* SQLITE_OMIT_VACUUM */
sl@0	7265
sl@0	7266	/*
sl@0	7267	** Return non-zero if a transaction is active.
sl@0	7268	*/
sl@0	7269	int sqlite3BtreeIsInTrans(Btree *p){
sl@0	7270	assert( p==0 \|\| sqlite3_mutex_held(p->db->mutex) );
sl@0	7271	return (p && (p->inTrans==TRANS_WRITE));
sl@0	7272	}
sl@0	7273
sl@0	7274	/*
sl@0	7275	** Return non-zero if a statement transaction is active.
sl@0	7276	*/
sl@0	7277	int sqlite3BtreeIsInStmt(Btree *p){
sl@0	7278	assert( sqlite3BtreeHoldsMutex(p) );
sl@0	7279	return (p->pBt && p->pBt->inStmt);
sl@0	7280	}
sl@0	7281
sl@0	7282	/*
sl@0	7283	** Return non-zero if a read (or write) transaction is active.
sl@0	7284	*/
sl@0	7285	int sqlite3BtreeIsInReadTrans(Btree *p){
sl@0	7286	assert( sqlite3_mutex_held(p->db->mutex) );
sl@0	7287	return (p && (p->inTrans!=TRANS_NONE));
sl@0	7288	}
sl@0	7289
sl@0	7290	/*
sl@0	7291	** This function returns a pointer to a blob of memory associated with
sl@0	7292	** a single shared-btree. The memory is used by client code for its own
sl@0	7293	** purposes (for example, to store a high-level schema associated with
sl@0	7294	** the shared-btree). The btree layer manages reference counting issues.
sl@0	7295	**
sl@0	7296	** The first time this is called on a shared-btree, nBytes bytes of memory
sl@0	7297	** are allocated, zeroed, and returned to the caller. For each subsequent
sl@0	7298	** call the nBytes parameter is ignored and a pointer to the same blob
sl@0	7299	** of memory returned.
sl@0	7300	**
sl@0	7301	** If the nBytes parameter is 0 and the blob of memory has not yet been
sl@0	7302	** allocated, a null pointer is returned. If the blob has already been
sl@0	7303	** allocated, it is returned as normal.
sl@0	7304	**
sl@0	7305	** Just before the shared-btree is closed, the function passed as the
sl@0	7306	** xFree argument when the memory allocation was made is invoked on the
sl@0	7307	** blob of allocated memory. This function should not call sqlite3_free()
sl@0	7308	** on the memory, the btree layer does that.
sl@0	7309	*/
sl@0	7310	void sqlite3BtreeSchema(Btree p, int nBytes, void(xFree)(void )){
sl@0	7311	BtShared *pBt = p->pBt;
sl@0	7312	sqlite3BtreeEnter(p);
sl@0	7313	if( !pBt->pSchema && nBytes ){
sl@0	7314	pBt->pSchema = sqlite3MallocZero(nBytes);
sl@0	7315	pBt->xFreeSchema = xFree;
sl@0	7316	}
sl@0	7317	sqlite3BtreeLeave(p);
sl@0	7318	return pBt->pSchema;
sl@0	7319	}
sl@0	7320
sl@0	7321	/*
sl@0	7322	** Return true if another user of the same shared btree as the argument
sl@0	7323	** handle holds an exclusive lock on the sqlite_master table.
sl@0	7324	*/
sl@0	7325	int sqlite3BtreeSchemaLocked(Btree *p){
sl@0	7326	int rc;
sl@0	7327	assert( sqlite3_mutex_held(p->db->mutex) );
sl@0	7328	sqlite3BtreeEnter(p);
sl@0	7329	rc = (queryTableLock(p, MASTER_ROOT, READ_LOCK)!=SQLITE_OK);
sl@0	7330	sqlite3BtreeLeave(p);
sl@0	7331	return rc;
sl@0	7332	}
sl@0	7333
sl@0	7334
sl@0	7335	#ifndef SQLITE_OMIT_SHARED_CACHE
sl@0	7336	/*
sl@0	7337	** Obtain a lock on the table whose root page is iTab. The
sl@0	7338	** lock is a write lock if isWritelock is true or a read lock
sl@0	7339	** if it is false.
sl@0	7340	*/
sl@0	7341	int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
sl@0	7342	int rc = SQLITE_OK;
sl@0	7343	if( p->sharable ){
sl@0	7344	u8 lockType = READ_LOCK + isWriteLock;
sl@0	7345	assert( READ_LOCK+1==WRITE_LOCK );
sl@0	7346	assert( isWriteLock==0 \|\| isWriteLock==1 );
sl@0	7347	sqlite3BtreeEnter(p);
sl@0	7348	rc = queryTableLock(p, iTab, lockType);
sl@0	7349	if( rc==SQLITE_OK ){
sl@0	7350	rc = lockTable(p, iTab, lockType);
sl@0	7351	}
sl@0	7352	sqlite3BtreeLeave(p);
sl@0	7353	}
sl@0	7354	return rc;
sl@0	7355	}
sl@0	7356	#endif
sl@0	7357
sl@0	7358	#ifndef SQLITE_OMIT_INCRBLOB
sl@0	7359	/*
sl@0	7360	** Argument pCsr must be a cursor opened for writing on an
sl@0	7361	** INTKEY table currently pointing at a valid table entry.
sl@0	7362	** This function modifies the data stored as part of that entry.
sl@0	7363	** Only the data content may only be modified, it is not possible
sl@0	7364	** to change the length of the data stored.
sl@0	7365	*/
sl@0	7366	int sqlite3BtreePutData(BtCursor pCsr, u32 offset, u32 amt, void z){
sl@0	7367	assert( cursorHoldsMutex(pCsr) );
sl@0	7368	assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
sl@0	7369	assert(pCsr->isIncrblobHandle);
sl@0	7370
sl@0	7371	restoreCursorPosition(pCsr);
sl@0	7372	assert( pCsr->eState!=CURSOR_REQUIRESEEK );
sl@0	7373	if( pCsr->eState!=CURSOR_VALID ){
sl@0	7374	return SQLITE_ABORT;
sl@0	7375	}
sl@0	7376
sl@0	7377	/* Check some preconditions:
sl@0	7378	** (a) the cursor is open for writing,
sl@0	7379	** (b) there is no read-lock on the table being modified and
sl@0	7380	** (c) the cursor points at a valid row of an intKey table.
sl@0	7381	*/
sl@0	7382	if( !pCsr->wrFlag ){
sl@0	7383	return SQLITE_READONLY;
sl@0	7384	}
sl@0	7385	assert( !pCsr->pBt->readOnly
sl@0	7386	&& pCsr->pBt->inTransaction==TRANS_WRITE );
sl@0	7387	if( checkReadLocks(pCsr->pBtree, pCsr->pgnoRoot, pCsr, 0) ){
sl@0	7388	return SQLITE_LOCKED; /* The table pCur points to has a read lock */
sl@0	7389	}
sl@0	7390	if( pCsr->eState==CURSOR_INVALID \|\| !pCsr->apPage[pCsr->iPage]->intKey ){
sl@0	7391	return SQLITE_ERROR;
sl@0	7392	}
sl@0	7393
sl@0	7394	return accessPayload(pCsr, offset, amt, (unsigned char *)z, 0, 1);
sl@0	7395	}
sl@0	7396
sl@0	7397	/*
sl@0	7398	** Set a flag on this cursor to cache the locations of pages from the
sl@0	7399	** overflow list for the current row. This is used by cursors opened
sl@0	7400	** for incremental blob IO only.
sl@0	7401	**
sl@0	7402	** This function sets a flag only. The actual page location cache
sl@0	7403	** (stored in BtCursor.aOverflow[]) is allocated and used by function
sl@0	7404	** accessPayload() (the worker function for sqlite3BtreeData() and
sl@0	7405	** sqlite3BtreePutData()).
sl@0	7406	*/
sl@0	7407	void sqlite3BtreeCacheOverflow(BtCursor *pCur){
sl@0	7408	assert( cursorHoldsMutex(pCur) );
sl@0	7409	assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
sl@0	7410	assert(!pCur->isIncrblobHandle);
sl@0	7411	assert(!pCur->aOverflow);
sl@0	7412	pCur->isIncrblobHandle = 1;
sl@0	7413	}
sl@0	7414	#endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--