blob: 7324b37fd67480bf5d703ceab776c49f14621166 [file] [log] [blame]
drha059ad02001-04-17 20:09:11 +00001/*
drh9e572e62004-04-23 23:43:10 +00002** 2004 April 6
drha059ad02001-04-17 20:09:11 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drha059ad02001-04-17 20:09:11 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
drha059ad02001-04-17 20:09:11 +000010**
11*************************************************************************
drh14684382006-11-30 13:05:29 +000012** $Id: btree.c,v 1.331 2006/11/30 13:05:29 drh Exp $
drh8b2f49b2001-06-08 00:21:52 +000013**
14** This file implements a external (disk-based) database using BTrees.
15** For a detailed discussion of BTrees, refer to
16**
17** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3:
18** "Sorting And Searching", pages 473-480. Addison-Wesley
19** Publishing Company, Reading, Massachusetts.
20**
21** The basic idea is that each page of the file contains N database
22** entries and N+1 pointers to subpages.
23**
24** ----------------------------------------------------------------
25** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N) | Ptr(N+1) |
26** ----------------------------------------------------------------
27**
28** All of the keys on the page that Ptr(0) points to have values less
29** than Key(0). All of the keys on page Ptr(1) and its subpages have
30** values greater than Key(0) and less than Key(1). All of the keys
31** on Ptr(N+1) and its subpages have values greater than Key(N). And
32** so forth.
33**
drh5e00f6c2001-09-13 13:46:56 +000034** Finding a particular key requires reading O(log(M)) pages from the
35** disk where M is the number of entries in the tree.
drh8b2f49b2001-06-08 00:21:52 +000036**
37** In this implementation, a single file can hold one or more separate
38** BTrees. Each BTree is identified by the index of its root page. The
drh9e572e62004-04-23 23:43:10 +000039** key and data for any entry are combined to form the "payload". A
40** fixed amount of payload can be carried directly on the database
41** page. If the payload is larger than the preset amount then surplus
42** bytes are stored on overflow pages. The payload for an entry
43** and the preceding pointer are combined to form a "Cell". Each
44** page has a small header which contains the Ptr(N+1) pointer and other
45** information such as the size of key and data.
drh8b2f49b2001-06-08 00:21:52 +000046**
drh9e572e62004-04-23 23:43:10 +000047** FORMAT DETAILS
48**
49** The file is divided into pages. The first page is called page 1,
50** the second is page 2, and so forth. A page number of zero indicates
51** "no such page". The page size can be anything between 512 and 65536.
52** Each page can be either a btree page, a freelist page or an overflow
53** page.
54**
55** The first page is always a btree page. The first 100 bytes of the first
drh271efa52004-05-30 19:19:05 +000056** page contain a special header (the "file header") that describes the file.
57** The format of the file header is as follows:
drh9e572e62004-04-23 23:43:10 +000058**
59** OFFSET SIZE DESCRIPTION
drhde647132004-05-07 17:57:49 +000060** 0 16 Header string: "SQLite format 3\000"
drh9e572e62004-04-23 23:43:10 +000061** 16 2 Page size in bytes.
62** 18 1 File format write version
63** 19 1 File format read version
drh6f11bef2004-05-13 01:12:56 +000064** 20 1 Bytes of unused space at the end of each page
65** 21 1 Max embedded payload fraction
66** 22 1 Min embedded payload fraction
67** 23 1 Min leaf payload fraction
68** 24 4 File change counter
69** 28 4 Reserved for future use
drh9e572e62004-04-23 23:43:10 +000070** 32 4 First freelist page
71** 36 4 Number of freelist pages in the file
72** 40 60 15 4-byte meta values passed to higher layers
73**
74** All of the integer values are big-endian (most significant byte first).
drh6f11bef2004-05-13 01:12:56 +000075**
drhab01f612004-05-22 02:55:23 +000076** The file change counter is incremented when the database is changed more
drh6f11bef2004-05-13 01:12:56 +000077** than once within the same second. This counter, together with the
78** modification time of the file, allows other processes to know
79** when the file has changed and thus when they need to flush their
80** cache.
81**
82** The max embedded payload fraction is the amount of the total usable
83** space in a page that can be consumed by a single cell for standard
84** B-tree (non-LEAFDATA) tables. A value of 255 means 100%. The default
85** is to limit the maximum cell size so that at least 4 cells will fit
drhab01f612004-05-22 02:55:23 +000086** on one page. Thus the default max embedded payload fraction is 64.
drh6f11bef2004-05-13 01:12:56 +000087**
88** If the payload for a cell is larger than the max payload, then extra
89** payload is spilled to overflow pages. Once an overflow page is allocated,
90** as many bytes as possible are moved into the overflow pages without letting
91** the cell size drop below the min embedded payload fraction.
92**
93** The min leaf payload fraction is like the min embedded payload fraction
94** except that it applies to leaf nodes in a LEAFDATA tree. The maximum
95** payload fraction for a LEAFDATA tree is always 100% (or 255) and it
96** not specified in the header.
drh9e572e62004-04-23 23:43:10 +000097**
drh43605152004-05-29 21:46:49 +000098** Each btree pages is divided into three sections: The header, the
99** cell pointer array, and the cell area area. Page 1 also has a 100-byte
drh271efa52004-05-30 19:19:05 +0000100** file header that occurs before the page header.
101**
102** |----------------|
103** | file header | 100 bytes. Page 1 only.
104** |----------------|
105** | page header | 8 bytes for leaves. 12 bytes for interior nodes
106** |----------------|
107** | cell pointer | | 2 bytes per cell. Sorted order.
108** | array | | Grows downward
109** | | v
110** |----------------|
111** | unallocated |
112** | space |
113** |----------------| ^ Grows upwards
114** | cell content | | Arbitrary order interspersed with freeblocks.
115** | area | | and free space fragments.
116** |----------------|
drh43605152004-05-29 21:46:49 +0000117**
118** The page headers looks like this:
drh9e572e62004-04-23 23:43:10 +0000119**
120** OFFSET SIZE DESCRIPTION
drh6f11bef2004-05-13 01:12:56 +0000121** 0 1 Flags. 1: intkey, 2: zerodata, 4: leafdata, 8: leaf
drh9e572e62004-04-23 23:43:10 +0000122** 1 2 byte offset to the first freeblock
drh43605152004-05-29 21:46:49 +0000123** 3 2 number of cells on this page
drh271efa52004-05-30 19:19:05 +0000124** 5 2 first byte of the cell content area
drh43605152004-05-29 21:46:49 +0000125** 7 1 number of fragmented free bytes
drh271efa52004-05-30 19:19:05 +0000126** 8 4 Right child (the Ptr(N+1) value). Omitted on leaves.
drh9e572e62004-04-23 23:43:10 +0000127**
128** The flags define the format of this btree page. The leaf flag means that
129** this page has no children. The zerodata flag means that this page carries
drh44f87bd2004-09-27 13:19:51 +0000130** only keys and no data. The intkey flag means that the key is a integer
131** which is stored in the key size entry of the cell header rather than in
132** the payload area.
drh9e572e62004-04-23 23:43:10 +0000133**
drh43605152004-05-29 21:46:49 +0000134** The cell pointer array begins on the first byte after the page header.
135** The cell pointer array contains zero or more 2-byte numbers which are
136** offsets from the beginning of the page to the cell content in the cell
137** content area. The cell pointers occur in sorted order. The system strives
138** to keep free space after the last cell pointer so that new cells can
drh44f87bd2004-09-27 13:19:51 +0000139** be easily added without having to defragment the page.
drh43605152004-05-29 21:46:49 +0000140**
141** Cell content is stored at the very end of the page and grows toward the
142** beginning of the page.
143**
144** Unused space within the cell content area is collected into a linked list of
145** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset
146** to the first freeblock is given in the header. Freeblocks occur in
147** increasing order. Because a freeblock must be at least 4 bytes in size,
148** any group of 3 or fewer unused bytes in the cell content area cannot
149** exist on the freeblock chain. A group of 3 or fewer free bytes is called
150** a fragment. The total number of bytes in all fragments is recorded.
151** in the page header at offset 7.
152**
153** SIZE DESCRIPTION
154** 2 Byte offset of the next freeblock
155** 2 Bytes in this freeblock
156**
157** Cells are of variable length. Cells are stored in the cell content area at
158** the end of the page. Pointers to the cells are in the cell pointer array
159** that immediately follows the page header. Cells is not necessarily
160** contiguous or in order, but cell pointers are contiguous and in order.
161**
162** Cell content makes use of variable length integers. A variable
163** length integer is 1 to 9 bytes where the lower 7 bits of each
drh9e572e62004-04-23 23:43:10 +0000164** byte are used. The integer consists of all bytes that have bit 8 set and
drh6f11bef2004-05-13 01:12:56 +0000165** the first byte with bit 8 clear. The most significant byte of the integer
drhab01f612004-05-22 02:55:23 +0000166** appears first. A variable-length integer may not be more than 9 bytes long.
167** As a special case, all 8 bytes of the 9th byte are used as data. This
168** allows a 64-bit integer to be encoded in 9 bytes.
drh9e572e62004-04-23 23:43:10 +0000169**
170** 0x00 becomes 0x00000000
drh6f11bef2004-05-13 01:12:56 +0000171** 0x7f becomes 0x0000007f
172** 0x81 0x00 becomes 0x00000080
173** 0x82 0x00 becomes 0x00000100
174** 0x80 0x7f becomes 0x0000007f
175** 0x8a 0x91 0xd1 0xac 0x78 becomes 0x12345678
drh9e572e62004-04-23 23:43:10 +0000176** 0x81 0x81 0x81 0x81 0x01 becomes 0x10204081
177**
178** Variable length integers are used for rowids and to hold the number of
179** bytes of key and data in a btree cell.
180**
drh43605152004-05-29 21:46:49 +0000181** The content of a cell looks like this:
drh9e572e62004-04-23 23:43:10 +0000182**
183** SIZE DESCRIPTION
drh3aac2dd2004-04-26 14:10:20 +0000184** 4 Page number of the left child. Omitted if leaf flag is set.
185** var Number of bytes of data. Omitted if the zerodata flag is set.
186** var Number of bytes of key. Or the key itself if intkey flag is set.
drh9e572e62004-04-23 23:43:10 +0000187** * Payload
188** 4 First page of the overflow chain. Omitted if no overflow
189**
190** Overflow pages form a linked list. Each page except the last is completely
191** filled with data (pagesize - 4 bytes). The last page can have as little
192** as 1 byte of data.
193**
194** SIZE DESCRIPTION
195** 4 Page number of next overflow page
196** * Data
197**
198** Freelist pages come in two subtypes: trunk pages and leaf pages. The
199** file header points to first in a linked list of trunk page. Each trunk
200** page points to multiple leaf pages. The content of a leaf page is
201** unspecified. A trunk page looks like this:
202**
203** SIZE DESCRIPTION
204** 4 Page number of next trunk page
205** 4 Number of leaf pointers on this page
206** * zero or more pages numbers of leaves
drha059ad02001-04-17 20:09:11 +0000207*/
208#include "sqliteInt.h"
209#include "pager.h"
210#include "btree.h"
drh1f595712004-06-15 01:40:29 +0000211#include "os.h"
drha059ad02001-04-17 20:09:11 +0000212#include <assert.h>
213
drhc96d8532005-05-03 12:30:33 +0000214/* Round up a number to the next larger multiple of 8. This is used
215** to force 8-byte alignment on 64-bit architectures.
216*/
217#define ROUND8(x) ((x+7)&~7)
218
219
drh4b70f112004-05-02 21:12:19 +0000220/* The following value is the maximum cell size assuming a maximum page
221** size give above.
222*/
drh2e38c322004-09-03 18:38:44 +0000223#define MX_CELL_SIZE(pBt) (pBt->pageSize-8)
drh4b70f112004-05-02 21:12:19 +0000224
225/* The maximum number of cells on a single page of the database. This
226** assumes a minimum cell size of 3 bytes. Such small cells will be
227** exceedingly rare, but they are possible.
228*/
drh2e38c322004-09-03 18:38:44 +0000229#define MX_CELL(pBt) ((pBt->pageSize-8)/3)
drh4b70f112004-05-02 21:12:19 +0000230
paulb95a8862003-04-01 21:16:41 +0000231/* Forward declarations */
drh3aac2dd2004-04-26 14:10:20 +0000232typedef struct MemPage MemPage;
danielk1977aef0bf62005-12-30 16:28:01 +0000233typedef struct BtLock BtLock;
paulb95a8862003-04-01 21:16:41 +0000234
drh8c42ca92001-06-22 19:15:00 +0000235/*
drhbd03cae2001-06-02 02:40:57 +0000236** This is a magic string that appears at the beginning of every
drh8c42ca92001-06-22 19:15:00 +0000237** SQLite database in order to identify the file as a real database.
drh556b2a22005-06-14 16:04:05 +0000238**
239** You can change this value at compile-time by specifying a
240** -DSQLITE_FILE_HEADER="..." on the compiler command-line. The
241** header must be exactly 16 bytes including the zero-terminator so
242** the string itself should be 15 characters long. If you change
243** the header, then your custom library will not be able to read
244** databases generated by the standard tools and the standard tools
245** will not be able to read databases created by your custom library.
246*/
247#ifndef SQLITE_FILE_HEADER /* 123456789 123456 */
248# define SQLITE_FILE_HEADER "SQLite format 3"
249#endif
250static const char zMagicHeader[] = SQLITE_FILE_HEADER;
drh08ed44e2001-04-29 23:32:55 +0000251
252/*
drh4b70f112004-05-02 21:12:19 +0000253** Page type flags. An ORed combination of these flags appear as the
254** first byte of every BTree page.
drh8c42ca92001-06-22 19:15:00 +0000255*/
drhde647132004-05-07 17:57:49 +0000256#define PTF_INTKEY 0x01
drh9e572e62004-04-23 23:43:10 +0000257#define PTF_ZERODATA 0x02
drh8b18dd42004-05-12 19:18:15 +0000258#define PTF_LEAFDATA 0x04
259#define PTF_LEAF 0x08
drh8c42ca92001-06-22 19:15:00 +0000260
261/*
drh9e572e62004-04-23 23:43:10 +0000262** As each page of the file is loaded into memory, an instance of the following
263** structure is appended and initialized to zero. This structure stores
264** information about the page that is decoded from the raw file page.
drh14acc042001-06-10 19:56:58 +0000265**
drh72f82862001-05-24 21:06:34 +0000266** The pParent field points back to the parent page. This allows us to
267** walk up the BTree from any leaf to the root. Care must be taken to
268** unref() the parent page pointer when this page is no longer referenced.
drhbd03cae2001-06-02 02:40:57 +0000269** The pageDestructor() routine handles that chore.
drh7e3b0a02001-04-28 16:52:40 +0000270*/
271struct MemPage {
drha6abd042004-06-09 17:37:22 +0000272 u8 isInit; /* True if previously initialized. MUST BE FIRST! */
drh43605152004-05-29 21:46:49 +0000273 u8 idxShift; /* True if Cell indices have changed */
274 u8 nOverflow; /* Number of overflow cell bodies in aCell[] */
275 u8 intKey; /* True if intkey flag is set */
276 u8 leaf; /* True if leaf flag is set */
277 u8 zeroData; /* True if table stores keys only */
278 u8 leafData; /* True if tables stores data on leaves only */
279 u8 hasData; /* True if this page stores data */
280 u8 hdrOffset; /* 100 for page 1. 0 otherwise */
drh271efa52004-05-30 19:19:05 +0000281 u8 childPtrSize; /* 0 if leaf==1. 4 if leaf==0 */
drha2fce642004-06-05 00:01:44 +0000282 u16 maxLocal; /* Copy of Btree.maxLocal or Btree.maxLeaf */
283 u16 minLocal; /* Copy of Btree.minLocal or Btree.minLeaf */
drh43605152004-05-29 21:46:49 +0000284 u16 cellOffset; /* Index in aData of first cell pointer */
285 u16 idxParent; /* Index in parent of this node */
286 u16 nFree; /* Number of free bytes on the page */
287 u16 nCell; /* Number of cells on this page, local and ovfl */
288 struct _OvflCell { /* Cells that will not fit on aData[] */
danielk1977aef0bf62005-12-30 16:28:01 +0000289 u8 *pCell; /* Pointers to the body of the overflow cell */
290 u16 idx; /* Insert this cell before idx-th non-overflow cell */
drha2fce642004-06-05 00:01:44 +0000291 } aOvfl[5];
drh47ded162006-01-06 01:42:58 +0000292 BtShared *pBt; /* Pointer back to BTree structure */
293 u8 *aData; /* Pointer back to the start of the page */
294 Pgno pgno; /* Page number for this page */
295 MemPage *pParent; /* The parent of this page. NULL for root */
drh8c42ca92001-06-22 19:15:00 +0000296};
drh7e3b0a02001-04-28 16:52:40 +0000297
298/*
drh3b7511c2001-05-26 13:15:44 +0000299** The in-memory image of a disk page has the auxiliary information appended
300** to the end. EXTRA_SIZE is the number of bytes of space needed to hold
301** that extra information.
302*/
drh3aac2dd2004-04-26 14:10:20 +0000303#define EXTRA_SIZE sizeof(MemPage)
drh3b7511c2001-05-26 13:15:44 +0000304
danielk1977aef0bf62005-12-30 16:28:01 +0000305/* Btree handle */
306struct Btree {
307 sqlite3 *pSqlite;
308 BtShared *pBt;
309 u8 inTrans; /* TRANS_NONE, TRANS_READ or TRANS_WRITE */
310};
311
312/*
313** Btree.inTrans may take one of the following values.
314**
315** If the shared-data extension is enabled, there may be multiple users
316** of the Btree structure. At most one of these may open a write transaction,
317** but any number may have active read transactions. Variable Btree.pDb
318** points to the handle that owns any current write-transaction.
319*/
320#define TRANS_NONE 0
321#define TRANS_READ 1
322#define TRANS_WRITE 2
323
drh3b7511c2001-05-26 13:15:44 +0000324/*
drha059ad02001-04-17 20:09:11 +0000325** Everything we need to know about an open database
326*/
danielk1977aef0bf62005-12-30 16:28:01 +0000327struct BtShared {
drha059ad02001-04-17 20:09:11 +0000328 Pager *pPager; /* The page cache */
drh306dc212001-05-21 13:45:10 +0000329 BtCursor *pCursor; /* A list of all open cursors */
drh3aac2dd2004-04-26 14:10:20 +0000330 MemPage *pPage1; /* First page of the database */
drhab01f612004-05-22 02:55:23 +0000331 u8 inStmt; /* True if we are in a statement subtransaction */
drh5df72a52002-06-06 23:16:05 +0000332 u8 readOnly; /* True if the underlying file is readonly */
drhab01f612004-05-22 02:55:23 +0000333 u8 maxEmbedFrac; /* Maximum payload as % of total page size */
334 u8 minEmbedFrac; /* Minimum payload as % of total page size */
335 u8 minLeafFrac; /* Minimum leaf payload as % of total page size */
drh90f5ecb2004-07-22 01:19:35 +0000336 u8 pageSizeFixed; /* True if the page size can no longer be changed */
drh057cd3a2005-02-15 16:23:02 +0000337#ifndef SQLITE_OMIT_AUTOVACUUM
338 u8 autoVacuum; /* True if database supports auto-vacuum */
339#endif
drha2fce642004-06-05 00:01:44 +0000340 u16 pageSize; /* Total number of bytes on a page */
341 u16 usableSize; /* Number of usable bytes on each page */
drh6f11bef2004-05-13 01:12:56 +0000342 int maxLocal; /* Maximum local payload in non-LEAFDATA tables */
343 int minLocal; /* Minimum local payload in non-LEAFDATA tables */
344 int maxLeaf; /* Maximum local payload in a LEAFDATA table */
345 int minLeaf; /* Minimum local payload in a LEAFDATA table */
drhb8ef32c2005-03-14 02:01:49 +0000346 BusyHandler *pBusyHandler; /* Callback for when there is lock contention */
danielk1977aef0bf62005-12-30 16:28:01 +0000347 u8 inTransaction; /* Transaction state */
danielk1977aef0bf62005-12-30 16:28:01 +0000348 int nRef; /* Number of references to this structure */
349 int nTransaction; /* Number of open transactions (read + write) */
danielk19772e94d4d2006-01-09 05:36:27 +0000350 void *pSchema; /* Pointer to space allocated by sqlite3BtreeSchema() */
351 void (*xFreeSchema)(void*); /* Destructor for BtShared.pSchema */
352#ifndef SQLITE_OMIT_SHARED_CACHE
danielk1977aef0bf62005-12-30 16:28:01 +0000353 BtLock *pLock; /* List of locks held on this shared-btree struct */
danielk1977e501b892006-01-09 06:29:47 +0000354 BtShared *pNext; /* Next in ThreadData.pBtree linked list */
danielk19772e94d4d2006-01-09 05:36:27 +0000355#endif
drha059ad02001-04-17 20:09:11 +0000356};
danielk1977ee5741e2004-05-31 10:01:34 +0000357
358/*
drhfa1a98a2004-05-14 19:08:17 +0000359** An instance of the following structure is used to hold information
drh271efa52004-05-30 19:19:05 +0000360** about a cell. The parseCellPtr() function fills in this structure
drhab01f612004-05-22 02:55:23 +0000361** based on information extract from the raw disk page.
drhfa1a98a2004-05-14 19:08:17 +0000362*/
363typedef struct CellInfo CellInfo;
364struct CellInfo {
drh43605152004-05-29 21:46:49 +0000365 u8 *pCell; /* Pointer to the start of cell content */
drhfa1a98a2004-05-14 19:08:17 +0000366 i64 nKey; /* The key for INTKEY tables, or number of bytes in key */
367 u32 nData; /* Number of bytes of data */
drh271efa52004-05-30 19:19:05 +0000368 u16 nHeader; /* Size of the cell content header in bytes */
drhfa1a98a2004-05-14 19:08:17 +0000369 u16 nLocal; /* Amount of payload held locally */
drhab01f612004-05-22 02:55:23 +0000370 u16 iOverflow; /* Offset to overflow page number. Zero if no overflow */
drh271efa52004-05-30 19:19:05 +0000371 u16 nSize; /* Size of the cell content on the main b-tree page */
drhfa1a98a2004-05-14 19:08:17 +0000372};
373
374/*
drh365d68f2001-05-11 11:02:46 +0000375** A cursor is a pointer to a particular entry in the BTree.
376** The entry is identified by its MemPage and the index in
drha34b6762004-05-07 13:30:42 +0000377** MemPage.aCell[] of the entry.
drh365d68f2001-05-11 11:02:46 +0000378*/
drh72f82862001-05-24 21:06:34 +0000379struct BtCursor {
danielk1977aef0bf62005-12-30 16:28:01 +0000380 Btree *pBtree; /* The Btree to which this cursor belongs */
drh14acc042001-06-10 19:56:58 +0000381 BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */
drh3aac2dd2004-04-26 14:10:20 +0000382 int (*xCompare)(void*,int,const void*,int,const void*); /* Key comp func */
383 void *pArg; /* First arg to xCompare() */
drh8b2f49b2001-06-08 00:21:52 +0000384 Pgno pgnoRoot; /* The root page of this tree */
drh5e2f8b92001-05-28 00:41:15 +0000385 MemPage *pPage; /* Page that contains the entry */
drh3aac2dd2004-04-26 14:10:20 +0000386 int idx; /* Index of the entry in pPage->aCell[] */
drhfa1a98a2004-05-14 19:08:17 +0000387 CellInfo info; /* A parse of the cell we are pointing at */
drhecdc7532001-09-23 02:35:53 +0000388 u8 wrFlag; /* True if writable */
danielk1977da184232006-01-05 11:34:32 +0000389 u8 eState; /* One of the CURSOR_XXX constants (see below) */
drh4eeb1ff2006-03-23 14:03:00 +0000390 void *pKey; /* Saved key that was cursor's last known position */
391 i64 nKey; /* Size of pKey, or last integer key */
danielk1977da184232006-01-05 11:34:32 +0000392 int skip; /* (skip<0) -> Prev() is a no-op. (skip>0) -> Next() is */
drh365d68f2001-05-11 11:02:46 +0000393};
drh7e3b0a02001-04-28 16:52:40 +0000394
drha059ad02001-04-17 20:09:11 +0000395/*
drh980b1a72006-08-16 16:42:48 +0000396** Potential values for BtCursor.eState.
danielk1977da184232006-01-05 11:34:32 +0000397**
398** CURSOR_VALID:
399** Cursor points to a valid entry. getPayload() etc. may be called.
400**
401** CURSOR_INVALID:
402** Cursor does not point to a valid entry. This can happen (for example)
403** because the table is empty or because BtreeCursorFirst() has not been
404** called.
405**
406** CURSOR_REQUIRESEEK:
407** The table that this cursor was opened on still exists, but has been
408** modified since the cursor was last used. The cursor position is saved
409** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
danielk1977955de522006-02-10 02:27:42 +0000410** this state, restoreOrClearCursorPosition() can be called to attempt to
411** seek the cursor to the saved position.
danielk1977da184232006-01-05 11:34:32 +0000412*/
413#define CURSOR_INVALID 0
414#define CURSOR_VALID 1
415#define CURSOR_REQUIRESEEK 2
416
417/*
drh615ae552005-01-16 23:21:00 +0000418** The TRACE macro will print high-level status information about the
419** btree operation when the global variable sqlite3_btree_trace is
420** enabled.
421*/
422#if SQLITE_TEST
423# define TRACE(X) if( sqlite3_btree_trace )\
424 { sqlite3DebugPrintf X; fflush(stdout); }
drh0f7eb612006-08-08 13:51:43 +0000425int sqlite3_btree_trace=0; /* True to enable tracing */
drh615ae552005-01-16 23:21:00 +0000426#else
427# define TRACE(X)
428#endif
drh615ae552005-01-16 23:21:00 +0000429
430/*
drh66cbd152004-09-01 16:12:25 +0000431** Forward declaration
432*/
drh980b1a72006-08-16 16:42:48 +0000433static int checkReadLocks(Btree*,Pgno,BtCursor*);
drh66cbd152004-09-01 16:12:25 +0000434
drh66cbd152004-09-01 16:12:25 +0000435/*
drhab01f612004-05-22 02:55:23 +0000436** Read or write a two- and four-byte big-endian integer values.
drh0d316a42002-08-11 20:10:47 +0000437*/
drh9e572e62004-04-23 23:43:10 +0000438static u32 get2byte(unsigned char *p){
439 return (p[0]<<8) | p[1];
drh0d316a42002-08-11 20:10:47 +0000440}
drh9e572e62004-04-23 23:43:10 +0000441static u32 get4byte(unsigned char *p){
442 return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
443}
drh9e572e62004-04-23 23:43:10 +0000444static void put2byte(unsigned char *p, u32 v){
445 p[0] = v>>8;
446 p[1] = v;
447}
448static void put4byte(unsigned char *p, u32 v){
449 p[0] = v>>24;
450 p[1] = v>>16;
451 p[2] = v>>8;
452 p[3] = v;
453}
drh6f11bef2004-05-13 01:12:56 +0000454
drh9e572e62004-04-23 23:43:10 +0000455/*
drhab01f612004-05-22 02:55:23 +0000456** Routines to read and write variable-length integers. These used to
457** be defined locally, but now we use the varint routines in the util.c
458** file.
drh9e572e62004-04-23 23:43:10 +0000459*/
drh6d2fb152004-05-14 16:50:06 +0000460#define getVarint sqlite3GetVarint
drh504b6982006-01-22 21:52:56 +0000461/* #define getVarint32 sqlite3GetVarint32 */
462#define getVarint32(A,B) ((*B=*(A))<=0x7f?1:sqlite3GetVarint32(A,B))
drh6d2fb152004-05-14 16:50:06 +0000463#define putVarint sqlite3PutVarint
drh0d316a42002-08-11 20:10:47 +0000464
danielk1977599fcba2004-11-08 07:13:13 +0000465/* The database page the PENDING_BYTE occupies. This page is never used.
466** TODO: This macro is very similary to PAGER_MJ_PGNO() in pager.c. They
467** should possibly be consolidated (presumably in pager.h).
drhfe9a9142006-03-14 12:59:10 +0000468**
469** If disk I/O is omitted (meaning that the database is stored purely
470** in memory) then there is no pending byte.
danielk1977599fcba2004-11-08 07:13:13 +0000471*/
drhfe9a9142006-03-14 12:59:10 +0000472#ifdef SQLITE_OMIT_DISKIO
473# define PENDING_BYTE_PAGE(pBt) 0x7fffffff
474#else
475# define PENDING_BYTE_PAGE(pBt) ((PENDING_BYTE/(pBt)->pageSize)+1)
476#endif
danielk1977afcdd022004-10-31 16:25:42 +0000477
danielk1977aef0bf62005-12-30 16:28:01 +0000478/*
479** A linked list of the following structures is stored at BtShared.pLock.
480** Locks are added (or upgraded from READ_LOCK to WRITE_LOCK) when a cursor
481** is opened on the table with root page BtShared.iTable. Locks are removed
482** from this list when a transaction is committed or rolled back, or when
483** a btree handle is closed.
484*/
485struct BtLock {
486 Btree *pBtree; /* Btree handle holding this lock */
487 Pgno iTable; /* Root page of table */
488 u8 eLock; /* READ_LOCK or WRITE_LOCK */
489 BtLock *pNext; /* Next in BtShared.pLock list */
490};
491
492/* Candidate values for BtLock.eLock */
493#define READ_LOCK 1
494#define WRITE_LOCK 2
495
496#ifdef SQLITE_OMIT_SHARED_CACHE
497 /*
498 ** The functions queryTableLock(), lockTable() and unlockAllTables()
499 ** manipulate entries in the BtShared.pLock linked list used to store
500 ** shared-cache table level locks. If the library is compiled with the
501 ** shared-cache feature disabled, then there is only ever one user
danielk1977da184232006-01-05 11:34:32 +0000502 ** of each BtShared structure and so this locking is not necessary.
503 ** So define the lock related functions as no-ops.
danielk1977aef0bf62005-12-30 16:28:01 +0000504 */
505 #define queryTableLock(a,b,c) SQLITE_OK
506 #define lockTable(a,b,c) SQLITE_OK
danielk1977da184232006-01-05 11:34:32 +0000507 #define unlockAllTables(a)
danielk1977aef0bf62005-12-30 16:28:01 +0000508#else
509
danielk1977e7259292006-01-13 06:33:23 +0000510
danielk1977da184232006-01-05 11:34:32 +0000511/*
danielk1977aef0bf62005-12-30 16:28:01 +0000512** Query to see if btree handle p may obtain a lock of type eLock
513** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
514** SQLITE_OK if the lock may be obtained (by calling lockTable()), or
danielk1977c87d34d2006-01-06 13:00:28 +0000515** SQLITE_LOCKED if not.
danielk1977aef0bf62005-12-30 16:28:01 +0000516*/
517static int queryTableLock(Btree *p, Pgno iTab, u8 eLock){
518 BtShared *pBt = p->pBt;
519 BtLock *pIter;
520
danielk1977da184232006-01-05 11:34:32 +0000521 /* This is a no-op if the shared-cache is not enabled */
drh6f7adc82006-01-11 21:41:20 +0000522 if( 0==sqlite3ThreadDataReadOnly()->useSharedData ){
danielk1977da184232006-01-05 11:34:32 +0000523 return SQLITE_OK;
524 }
525
526 /* This (along with lockTable()) is where the ReadUncommitted flag is
527 ** dealt with. If the caller is querying for a read-lock and the flag is
528 ** set, it is unconditionally granted - even if there are write-locks
529 ** on the table. If a write-lock is requested, the ReadUncommitted flag
530 ** is not considered.
531 **
532 ** In function lockTable(), if a read-lock is demanded and the
533 ** ReadUncommitted flag is set, no entry is added to the locks list
534 ** (BtShared.pLock).
535 **
536 ** To summarize: If the ReadUncommitted flag is set, then read cursors do
537 ** not create or respect table locks. The locking procedure for a
538 ** write-cursor does not change.
539 */
540 if(
541 !p->pSqlite ||
542 0==(p->pSqlite->flags&SQLITE_ReadUncommitted) ||
543 eLock==WRITE_LOCK ||
drh47ded162006-01-06 01:42:58 +0000544 iTab==MASTER_ROOT
danielk1977da184232006-01-05 11:34:32 +0000545 ){
546 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
547 if( pIter->pBtree!=p && pIter->iTable==iTab &&
548 (pIter->eLock!=eLock || eLock!=READ_LOCK) ){
danielk1977c87d34d2006-01-06 13:00:28 +0000549 return SQLITE_LOCKED;
danielk1977da184232006-01-05 11:34:32 +0000550 }
danielk1977aef0bf62005-12-30 16:28:01 +0000551 }
552 }
553 return SQLITE_OK;
554}
555
556/*
557** Add a lock on the table with root-page iTable to the shared-btree used
558** by Btree handle p. Parameter eLock must be either READ_LOCK or
559** WRITE_LOCK.
560**
561** SQLITE_OK is returned if the lock is added successfully. SQLITE_BUSY and
562** SQLITE_NOMEM may also be returned.
563*/
564static int lockTable(Btree *p, Pgno iTable, u8 eLock){
565 BtShared *pBt = p->pBt;
566 BtLock *pLock = 0;
567 BtLock *pIter;
568
danielk1977da184232006-01-05 11:34:32 +0000569 /* This is a no-op if the shared-cache is not enabled */
drh6f7adc82006-01-11 21:41:20 +0000570 if( 0==sqlite3ThreadDataReadOnly()->useSharedData ){
danielk1977da184232006-01-05 11:34:32 +0000571 return SQLITE_OK;
572 }
573
danielk1977aef0bf62005-12-30 16:28:01 +0000574 assert( SQLITE_OK==queryTableLock(p, iTable, eLock) );
575
danielk1977da184232006-01-05 11:34:32 +0000576 /* If the read-uncommitted flag is set and a read-lock is requested,
577 ** return early without adding an entry to the BtShared.pLock list. See
578 ** comment in function queryTableLock() for more info on handling
579 ** the ReadUncommitted flag.
580 */
581 if(
582 (p->pSqlite) &&
583 (p->pSqlite->flags&SQLITE_ReadUncommitted) &&
584 (eLock==READ_LOCK) &&
drh47ded162006-01-06 01:42:58 +0000585 iTable!=MASTER_ROOT
danielk1977da184232006-01-05 11:34:32 +0000586 ){
587 return SQLITE_OK;
588 }
589
danielk1977aef0bf62005-12-30 16:28:01 +0000590 /* First search the list for an existing lock on this table. */
591 for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
592 if( pIter->iTable==iTable && pIter->pBtree==p ){
593 pLock = pIter;
594 break;
595 }
596 }
597
598 /* If the above search did not find a BtLock struct associating Btree p
599 ** with table iTable, allocate one and link it into the list.
600 */
601 if( !pLock ){
602 pLock = (BtLock *)sqliteMalloc(sizeof(BtLock));
603 if( !pLock ){
604 return SQLITE_NOMEM;
605 }
606 pLock->iTable = iTable;
607 pLock->pBtree = p;
608 pLock->pNext = pBt->pLock;
609 pBt->pLock = pLock;
610 }
611
612 /* Set the BtLock.eLock variable to the maximum of the current lock
613 ** and the requested lock. This means if a write-lock was already held
614 ** and a read-lock requested, we don't incorrectly downgrade the lock.
615 */
616 assert( WRITE_LOCK>READ_LOCK );
danielk19775118b912005-12-30 16:31:53 +0000617 if( eLock>pLock->eLock ){
618 pLock->eLock = eLock;
619 }
danielk1977aef0bf62005-12-30 16:28:01 +0000620
621 return SQLITE_OK;
622}
623
624/*
625** Release all the table locks (locks obtained via calls to the lockTable()
626** procedure) held by Btree handle p.
627*/
628static void unlockAllTables(Btree *p){
629 BtLock **ppIter = &p->pBt->pLock;
danielk1977da184232006-01-05 11:34:32 +0000630
631 /* If the shared-cache extension is not enabled, there should be no
632 ** locks in the BtShared.pLock list, making this procedure a no-op. Assert
633 ** that this is the case.
634 */
drh6f7adc82006-01-11 21:41:20 +0000635 assert( sqlite3ThreadDataReadOnly()->useSharedData || 0==*ppIter );
danielk1977da184232006-01-05 11:34:32 +0000636
danielk1977aef0bf62005-12-30 16:28:01 +0000637 while( *ppIter ){
638 BtLock *pLock = *ppIter;
639 if( pLock->pBtree==p ){
640 *ppIter = pLock->pNext;
641 sqliteFree(pLock);
642 }else{
643 ppIter = &pLock->pNext;
644 }
645 }
646}
647#endif /* SQLITE_OMIT_SHARED_CACHE */
648
drh980b1a72006-08-16 16:42:48 +0000649static void releasePage(MemPage *pPage); /* Forward reference */
650
651/*
652** Save the current cursor position in the variables BtCursor.nKey
653** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
654*/
655static int saveCursorPosition(BtCursor *pCur){
656 int rc;
657
658 assert( CURSOR_VALID==pCur->eState );
659 assert( 0==pCur->pKey );
660
661 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
662
663 /* If this is an intKey table, then the above call to BtreeKeySize()
664 ** stores the integer key in pCur->nKey. In this case this value is
665 ** all that is required. Otherwise, if pCur is not open on an intKey
666 ** table, then malloc space for and store the pCur->nKey bytes of key
667 ** data.
668 */
669 if( rc==SQLITE_OK && 0==pCur->pPage->intKey){
670 void *pKey = sqliteMalloc(pCur->nKey);
671 if( pKey ){
672 rc = sqlite3BtreeKey(pCur, 0, pCur->nKey, pKey);
673 if( rc==SQLITE_OK ){
674 pCur->pKey = pKey;
675 }else{
676 sqliteFree(pKey);
677 }
678 }else{
679 rc = SQLITE_NOMEM;
680 }
681 }
682 assert( !pCur->pPage->intKey || !pCur->pKey );
683
684 if( rc==SQLITE_OK ){
685 releasePage(pCur->pPage);
686 pCur->pPage = 0;
687 pCur->eState = CURSOR_REQUIRESEEK;
688 }
689
690 return rc;
691}
692
693/*
694** Save the positions of all cursors except pExcept open on the table
695** with root-page iRoot. Usually, this is called just before cursor
696** pExcept is used to modify the table (BtreeDelete() or BtreeInsert()).
697*/
698static int saveAllCursors(BtShared *pBt, Pgno iRoot, BtCursor *pExcept){
699 BtCursor *p;
700 for(p=pBt->pCursor; p; p=p->pNext){
701 if( p!=pExcept && (0==iRoot || p->pgnoRoot==iRoot) &&
702 p->eState==CURSOR_VALID ){
703 int rc = saveCursorPosition(p);
704 if( SQLITE_OK!=rc ){
705 return rc;
706 }
707 }
708 }
709 return SQLITE_OK;
710}
711
712/*
713** Restore the cursor to the position it was in (or as close to as possible)
714** when saveCursorPosition() was called. Note that this call deletes the
715** saved position info stored by saveCursorPosition(), so there can be
716** at most one effective restoreOrClearCursorPosition() call after each
717** saveCursorPosition().
718**
719** If the second argument argument - doSeek - is false, then instead of
720** returning the cursor to it's saved position, any saved position is deleted
721** and the cursor state set to CURSOR_INVALID.
722*/
723static int restoreOrClearCursorPositionX(BtCursor *pCur, int doSeek){
724 int rc = SQLITE_OK;
725 assert( pCur->eState==CURSOR_REQUIRESEEK );
726 pCur->eState = CURSOR_INVALID;
727 if( doSeek ){
728 rc = sqlite3BtreeMoveto(pCur, pCur->pKey, pCur->nKey, &pCur->skip);
729 }
730 if( rc==SQLITE_OK ){
731 sqliteFree(pCur->pKey);
732 pCur->pKey = 0;
733 assert( CURSOR_VALID==pCur->eState || CURSOR_INVALID==pCur->eState );
734 }
735 return rc;
736}
737
738#define restoreOrClearCursorPosition(p,x) \
739 (p->eState==CURSOR_REQUIRESEEK?restoreOrClearCursorPositionX(p,x):SQLITE_OK)
740
danielk1977599fcba2004-11-08 07:13:13 +0000741#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977afcdd022004-10-31 16:25:42 +0000742/*
drh42cac6d2004-11-20 20:31:11 +0000743** These macros define the location of the pointer-map entry for a
744** database page. The first argument to each is the number of usable
745** bytes on each page of the database (often 1024). The second is the
746** page number to look up in the pointer map.
danielk1977afcdd022004-10-31 16:25:42 +0000747**
748** PTRMAP_PAGENO returns the database page number of the pointer-map
749** page that stores the required pointer. PTRMAP_PTROFFSET returns
750** the offset of the requested map entry.
751**
752** If the pgno argument passed to PTRMAP_PAGENO is a pointer-map page,
753** then pgno is returned. So (pgno==PTRMAP_PAGENO(pgsz, pgno)) can be
danielk1977599fcba2004-11-08 07:13:13 +0000754** used to test if pgno is a pointer-map page. PTRMAP_ISPAGE implements
755** this test.
danielk1977afcdd022004-10-31 16:25:42 +0000756*/
danielk1977266664d2006-02-10 08:24:21 +0000757#define PTRMAP_PAGENO(pBt, pgno) ptrmapPageno(pBt, pgno)
758#define PTRMAP_PTROFFSET(pBt, pgno) (5*(pgno-ptrmapPageno(pBt, pgno)-1))
759#define PTRMAP_ISPAGE(pBt, pgno) (PTRMAP_PAGENO((pBt),(pgno))==(pgno))
760
761static Pgno ptrmapPageno(BtShared *pBt, Pgno pgno){
762 int nPagesPerMapPage = (pBt->usableSize/5)+1;
763 int iPtrMap = (pgno-2)/nPagesPerMapPage;
764 int ret = (iPtrMap*nPagesPerMapPage) + 2;
765 if( ret==PENDING_BYTE_PAGE(pBt) ){
766 ret++;
767 }
768 return ret;
769}
danielk1977a19df672004-11-03 11:37:07 +0000770
danielk1977afcdd022004-10-31 16:25:42 +0000771/*
drh615ae552005-01-16 23:21:00 +0000772** The pointer map is a lookup table that identifies the parent page for
773** each child page in the database file. The parent page is the page that
774** contains a pointer to the child. Every page in the database contains
775** 0 or 1 parent pages. (In this context 'database page' refers
776** to any page that is not part of the pointer map itself.) Each pointer map
777** entry consists of a single byte 'type' and a 4 byte parent page number.
778** The PTRMAP_XXX identifiers below are the valid types.
779**
780** The purpose of the pointer map is to facility moving pages from one
781** position in the file to another as part of autovacuum. When a page
782** is moved, the pointer in its parent must be updated to point to the
783** new location. The pointer map is used to locate the parent page quickly.
danielk1977afcdd022004-10-31 16:25:42 +0000784**
danielk1977687566d2004-11-02 12:56:41 +0000785** PTRMAP_ROOTPAGE: The database page is a root-page. The page-number is not
786** used in this case.
danielk1977afcdd022004-10-31 16:25:42 +0000787**
danielk1977687566d2004-11-02 12:56:41 +0000788** PTRMAP_FREEPAGE: The database page is an unused (free) page. The page-number
789** is not used in this case.
790**
791** PTRMAP_OVERFLOW1: The database page is the first page in a list of
792** overflow pages. The page number identifies the page that
793** contains the cell with a pointer to this overflow page.
794**
795** PTRMAP_OVERFLOW2: The database page is the second or later page in a list of
796** overflow pages. The page-number identifies the previous
797** page in the overflow page list.
798**
799** PTRMAP_BTREE: The database page is a non-root btree page. The page number
800** identifies the parent page in the btree.
danielk1977afcdd022004-10-31 16:25:42 +0000801*/
danielk1977687566d2004-11-02 12:56:41 +0000802#define PTRMAP_ROOTPAGE 1
803#define PTRMAP_FREEPAGE 2
804#define PTRMAP_OVERFLOW1 3
805#define PTRMAP_OVERFLOW2 4
806#define PTRMAP_BTREE 5
danielk1977afcdd022004-10-31 16:25:42 +0000807
808/*
809** Write an entry into the pointer map.
danielk1977687566d2004-11-02 12:56:41 +0000810**
811** This routine updates the pointer map entry for page number 'key'
812** so that it maps to type 'eType' and parent page number 'pgno'.
813** An error code is returned if something goes wrong, otherwise SQLITE_OK.
danielk1977afcdd022004-10-31 16:25:42 +0000814*/
danielk1977aef0bf62005-12-30 16:28:01 +0000815static int ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent){
danielk1977afcdd022004-10-31 16:25:42 +0000816 u8 *pPtrmap; /* The pointer map page */
817 Pgno iPtrmap; /* The pointer map page number */
818 int offset; /* Offset in pointer map page */
819 int rc;
820
danielk1977266664d2006-02-10 08:24:21 +0000821 /* The master-journal page number must never be used as a pointer map page */
822 assert( 0==PTRMAP_ISPAGE(pBt, PENDING_BYTE_PAGE(pBt)) );
823
danielk1977ac11ee62005-01-15 12:45:51 +0000824 assert( pBt->autoVacuum );
danielk1977fdb7cdb2005-01-17 02:12:18 +0000825 if( key==0 ){
drh49285702005-09-17 15:20:26 +0000826 return SQLITE_CORRUPT_BKPT;
danielk1977fdb7cdb2005-01-17 02:12:18 +0000827 }
danielk1977266664d2006-02-10 08:24:21 +0000828 iPtrmap = PTRMAP_PAGENO(pBt, key);
danielk1977afcdd022004-10-31 16:25:42 +0000829 rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap);
danielk1977687566d2004-11-02 12:56:41 +0000830 if( rc!=SQLITE_OK ){
danielk1977afcdd022004-10-31 16:25:42 +0000831 return rc;
832 }
danielk1977266664d2006-02-10 08:24:21 +0000833 offset = PTRMAP_PTROFFSET(pBt, key);
danielk1977afcdd022004-10-31 16:25:42 +0000834
drh615ae552005-01-16 23:21:00 +0000835 if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
836 TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
danielk1977afcdd022004-10-31 16:25:42 +0000837 rc = sqlite3pager_write(pPtrmap);
danielk19775558a8a2005-01-17 07:53:44 +0000838 if( rc==SQLITE_OK ){
839 pPtrmap[offset] = eType;
840 put4byte(&pPtrmap[offset+1], parent);
danielk1977afcdd022004-10-31 16:25:42 +0000841 }
danielk1977afcdd022004-10-31 16:25:42 +0000842 }
843
844 sqlite3pager_unref(pPtrmap);
danielk19775558a8a2005-01-17 07:53:44 +0000845 return rc;
danielk1977afcdd022004-10-31 16:25:42 +0000846}
847
848/*
849** Read an entry from the pointer map.
danielk1977687566d2004-11-02 12:56:41 +0000850**
851** This routine retrieves the pointer map entry for page 'key', writing
852** the type and parent page number to *pEType and *pPgno respectively.
853** An error code is returned if something goes wrong, otherwise SQLITE_OK.
danielk1977afcdd022004-10-31 16:25:42 +0000854*/
danielk1977aef0bf62005-12-30 16:28:01 +0000855static int ptrmapGet(BtShared *pBt, Pgno key, u8 *pEType, Pgno *pPgno){
danielk1977afcdd022004-10-31 16:25:42 +0000856 int iPtrmap; /* Pointer map page index */
857 u8 *pPtrmap; /* Pointer map page data */
858 int offset; /* Offset of entry in pointer map */
859 int rc;
860
danielk1977266664d2006-02-10 08:24:21 +0000861 iPtrmap = PTRMAP_PAGENO(pBt, key);
danielk1977afcdd022004-10-31 16:25:42 +0000862 rc = sqlite3pager_get(pBt->pPager, iPtrmap, (void **)&pPtrmap);
863 if( rc!=0 ){
864 return rc;
865 }
866
danielk1977266664d2006-02-10 08:24:21 +0000867 offset = PTRMAP_PTROFFSET(pBt, key);
drh43617e92006-03-06 20:55:46 +0000868 assert( pEType!=0 );
869 *pEType = pPtrmap[offset];
danielk1977687566d2004-11-02 12:56:41 +0000870 if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
danielk1977afcdd022004-10-31 16:25:42 +0000871
872 sqlite3pager_unref(pPtrmap);
drh49285702005-09-17 15:20:26 +0000873 if( *pEType<1 || *pEType>5 ) return SQLITE_CORRUPT_BKPT;
danielk1977afcdd022004-10-31 16:25:42 +0000874 return SQLITE_OK;
875}
876
877#endif /* SQLITE_OMIT_AUTOVACUUM */
878
drh0d316a42002-08-11 20:10:47 +0000879/*
drh271efa52004-05-30 19:19:05 +0000880** Given a btree page and a cell index (0 means the first cell on
881** the page, 1 means the second cell, and so forth) return a pointer
882** to the cell content.
883**
884** This routine works only for pages that do not contain overflow cells.
drh3aac2dd2004-04-26 14:10:20 +0000885*/
drh43605152004-05-29 21:46:49 +0000886static u8 *findCell(MemPage *pPage, int iCell){
887 u8 *data = pPage->aData;
888 assert( iCell>=0 );
889 assert( iCell<get2byte(&data[pPage->hdrOffset+3]) );
890 return data + get2byte(&data[pPage->cellOffset+2*iCell]);
891}
892
893/*
894** This a more complex version of findCell() that works for
895** pages that do contain overflow cells. See insert
896*/
897static u8 *findOverflowCell(MemPage *pPage, int iCell){
898 int i;
899 for(i=pPage->nOverflow-1; i>=0; i--){
drh6d08b4d2004-07-20 12:45:22 +0000900 int k;
901 struct _OvflCell *pOvfl;
902 pOvfl = &pPage->aOvfl[i];
903 k = pOvfl->idx;
904 if( k<=iCell ){
905 if( k==iCell ){
906 return pOvfl->pCell;
drh43605152004-05-29 21:46:49 +0000907 }
908 iCell--;
909 }
910 }
911 return findCell(pPage, iCell);
912}
913
914/*
915** Parse a cell content block and fill in the CellInfo structure. There
916** are two versions of this function. parseCell() takes a cell index
917** as the second argument and parseCellPtr() takes a pointer to the
918** body of the cell as its second argument.
919*/
920static void parseCellPtr(
drh3aac2dd2004-04-26 14:10:20 +0000921 MemPage *pPage, /* Page containing the cell */
drh43605152004-05-29 21:46:49 +0000922 u8 *pCell, /* Pointer to the cell text. */
drh6f11bef2004-05-13 01:12:56 +0000923 CellInfo *pInfo /* Fill in this structure */
drh3aac2dd2004-04-26 14:10:20 +0000924){
drh271efa52004-05-30 19:19:05 +0000925 int n; /* Number bytes in cell content header */
926 u32 nPayload; /* Number of bytes of cell payload */
drh43605152004-05-29 21:46:49 +0000927
928 pInfo->pCell = pCell;
drhab01f612004-05-22 02:55:23 +0000929 assert( pPage->leaf==0 || pPage->leaf==1 );
drh271efa52004-05-30 19:19:05 +0000930 n = pPage->childPtrSize;
931 assert( n==4-4*pPage->leaf );
drh8b18dd42004-05-12 19:18:15 +0000932 if( pPage->hasData ){
drh271efa52004-05-30 19:19:05 +0000933 n += getVarint32(&pCell[n], &nPayload);
drh8b18dd42004-05-12 19:18:15 +0000934 }else{
drh271efa52004-05-30 19:19:05 +0000935 nPayload = 0;
drh3aac2dd2004-04-26 14:10:20 +0000936 }
drh271efa52004-05-30 19:19:05 +0000937 pInfo->nData = nPayload;
drh504b6982006-01-22 21:52:56 +0000938 if( pPage->intKey ){
939 n += getVarint(&pCell[n], (u64 *)&pInfo->nKey);
940 }else{
941 u32 x;
942 n += getVarint32(&pCell[n], &x);
943 pInfo->nKey = x;
944 nPayload += x;
drh6f11bef2004-05-13 01:12:56 +0000945 }
drh504b6982006-01-22 21:52:56 +0000946 pInfo->nHeader = n;
drh271efa52004-05-30 19:19:05 +0000947 if( nPayload<=pPage->maxLocal ){
948 /* This is the (easy) common case where the entire payload fits
949 ** on the local page. No overflow is required.
950 */
951 int nSize; /* Total size of cell content in bytes */
drh6f11bef2004-05-13 01:12:56 +0000952 pInfo->nLocal = nPayload;
953 pInfo->iOverflow = 0;
drh271efa52004-05-30 19:19:05 +0000954 nSize = nPayload + n;
955 if( nSize<4 ){
956 nSize = 4; /* Minimum cell size is 4 */
drh43605152004-05-29 21:46:49 +0000957 }
drh271efa52004-05-30 19:19:05 +0000958 pInfo->nSize = nSize;
drh6f11bef2004-05-13 01:12:56 +0000959 }else{
drh271efa52004-05-30 19:19:05 +0000960 /* If the payload will not fit completely on the local page, we have
961 ** to decide how much to store locally and how much to spill onto
962 ** overflow pages. The strategy is to minimize the amount of unused
963 ** space on overflow pages while keeping the amount of local storage
964 ** in between minLocal and maxLocal.
965 **
966 ** Warning: changing the way overflow payload is distributed in any
967 ** way will result in an incompatible file format.
968 */
969 int minLocal; /* Minimum amount of payload held locally */
970 int maxLocal; /* Maximum amount of payload held locally */
971 int surplus; /* Overflow payload available for local storage */
972
973 minLocal = pPage->minLocal;
974 maxLocal = pPage->maxLocal;
975 surplus = minLocal + (nPayload - minLocal)%(pPage->pBt->usableSize - 4);
drh6f11bef2004-05-13 01:12:56 +0000976 if( surplus <= maxLocal ){
977 pInfo->nLocal = surplus;
978 }else{
979 pInfo->nLocal = minLocal;
980 }
981 pInfo->iOverflow = pInfo->nLocal + n;
982 pInfo->nSize = pInfo->iOverflow + 4;
983 }
drh3aac2dd2004-04-26 14:10:20 +0000984}
drh43605152004-05-29 21:46:49 +0000985static void parseCell(
986 MemPage *pPage, /* Page containing the cell */
987 int iCell, /* The cell index. First cell is 0 */
988 CellInfo *pInfo /* Fill in this structure */
989){
990 parseCellPtr(pPage, findCell(pPage, iCell), pInfo);
991}
drh3aac2dd2004-04-26 14:10:20 +0000992
993/*
drh43605152004-05-29 21:46:49 +0000994** Compute the total number of bytes that a Cell needs in the cell
995** data area of the btree-page. The return number includes the cell
996** data header and the local payload, but not any overflow page or
997** the space used by the cell pointer.
drh3b7511c2001-05-26 13:15:44 +0000998*/
danielk1977bc6ada42004-06-30 08:20:16 +0000999#ifndef NDEBUG
drh43605152004-05-29 21:46:49 +00001000static int cellSize(MemPage *pPage, int iCell){
drh6f11bef2004-05-13 01:12:56 +00001001 CellInfo info;
drh43605152004-05-29 21:46:49 +00001002 parseCell(pPage, iCell, &info);
1003 return info.nSize;
1004}
danielk1977bc6ada42004-06-30 08:20:16 +00001005#endif
drh43605152004-05-29 21:46:49 +00001006static int cellSizePtr(MemPage *pPage, u8 *pCell){
1007 CellInfo info;
1008 parseCellPtr(pPage, pCell, &info);
drh6f11bef2004-05-13 01:12:56 +00001009 return info.nSize;
drh3b7511c2001-05-26 13:15:44 +00001010}
1011
danielk197779a40da2005-01-16 08:00:01 +00001012#ifndef SQLITE_OMIT_AUTOVACUUM
drh3b7511c2001-05-26 13:15:44 +00001013/*
danielk197726836652005-01-17 01:33:13 +00001014** If the cell pCell, part of page pPage contains a pointer
danielk197779a40da2005-01-16 08:00:01 +00001015** to an overflow page, insert an entry into the pointer-map
1016** for the overflow page.
danielk1977ac11ee62005-01-15 12:45:51 +00001017*/
danielk197726836652005-01-17 01:33:13 +00001018static int ptrmapPutOvflPtr(MemPage *pPage, u8 *pCell){
danielk197779a40da2005-01-16 08:00:01 +00001019 if( pCell ){
1020 CellInfo info;
1021 parseCellPtr(pPage, pCell, &info);
1022 if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){
1023 Pgno ovfl = get4byte(&pCell[info.iOverflow]);
1024 return ptrmapPut(pPage->pBt, ovfl, PTRMAP_OVERFLOW1, pPage->pgno);
1025 }
danielk1977ac11ee62005-01-15 12:45:51 +00001026 }
danielk197779a40da2005-01-16 08:00:01 +00001027 return SQLITE_OK;
danielk1977ac11ee62005-01-15 12:45:51 +00001028}
danielk197726836652005-01-17 01:33:13 +00001029/*
1030** If the cell with index iCell on page pPage contains a pointer
1031** to an overflow page, insert an entry into the pointer-map
1032** for the overflow page.
1033*/
1034static int ptrmapPutOvfl(MemPage *pPage, int iCell){
1035 u8 *pCell;
1036 pCell = findOverflowCell(pPage, iCell);
1037 return ptrmapPutOvflPtr(pPage, pCell);
1038}
danielk197779a40da2005-01-16 08:00:01 +00001039#endif
1040
danielk1977ac11ee62005-01-15 12:45:51 +00001041
danielk1977aef0bf62005-12-30 16:28:01 +00001042/* A bunch of assert() statements to check the transaction state variables
1043** of handle p (type Btree*) are internally consistent.
1044*/
1045#define btreeIntegrity(p) \
1046 assert( p->inTrans!=TRANS_NONE || p->pBt->nTransaction<p->pBt->nRef ); \
1047 assert( p->pBt->nTransaction<=p->pBt->nRef ); \
1048 assert( p->pBt->inTransaction!=TRANS_NONE || p->pBt->nTransaction==0 ); \
1049 assert( p->pBt->inTransaction>=p->inTrans );
1050
drhda200cc2004-05-09 11:51:38 +00001051/*
drh72f82862001-05-24 21:06:34 +00001052** Defragment the page given. All Cells are moved to the
drh3a4a2d42005-11-24 14:24:28 +00001053** end of the page and all free space is collected into one
1054** big FreeBlk that occurs in between the header and cell
drh31beae92005-11-24 14:34:36 +00001055** pointer array and the cell content area.
drh365d68f2001-05-11 11:02:46 +00001056*/
drh2e38c322004-09-03 18:38:44 +00001057static int defragmentPage(MemPage *pPage){
drh43605152004-05-29 21:46:49 +00001058 int i; /* Loop counter */
1059 int pc; /* Address of a i-th cell */
1060 int addr; /* Offset of first byte after cell pointer array */
1061 int hdr; /* Offset to the page header */
1062 int size; /* Size of a cell */
1063 int usableSize; /* Number of usable bytes on a page */
1064 int cellOffset; /* Offset to the cell pointer array */
1065 int brk; /* Offset to the cell content area */
1066 int nCell; /* Number of cells on the page */
drh2e38c322004-09-03 18:38:44 +00001067 unsigned char *data; /* The page data */
1068 unsigned char *temp; /* Temp area for cell content */
drh2af926b2001-05-15 00:39:25 +00001069
drha34b6762004-05-07 13:30:42 +00001070 assert( sqlite3pager_iswriteable(pPage->aData) );
drh9e572e62004-04-23 23:43:10 +00001071 assert( pPage->pBt!=0 );
drh90f5ecb2004-07-22 01:19:35 +00001072 assert( pPage->pBt->usableSize <= SQLITE_MAX_PAGE_SIZE );
drh43605152004-05-29 21:46:49 +00001073 assert( pPage->nOverflow==0 );
drh2e38c322004-09-03 18:38:44 +00001074 temp = sqliteMalloc( pPage->pBt->pageSize );
1075 if( temp==0 ) return SQLITE_NOMEM;
drh43605152004-05-29 21:46:49 +00001076 data = pPage->aData;
drh9e572e62004-04-23 23:43:10 +00001077 hdr = pPage->hdrOffset;
drh43605152004-05-29 21:46:49 +00001078 cellOffset = pPage->cellOffset;
1079 nCell = pPage->nCell;
1080 assert( nCell==get2byte(&data[hdr+3]) );
1081 usableSize = pPage->pBt->usableSize;
1082 brk = get2byte(&data[hdr+5]);
1083 memcpy(&temp[brk], &data[brk], usableSize - brk);
1084 brk = usableSize;
1085 for(i=0; i<nCell; i++){
1086 u8 *pAddr; /* The i-th cell pointer */
1087 pAddr = &data[cellOffset + i*2];
1088 pc = get2byte(pAddr);
1089 assert( pc<pPage->pBt->usableSize );
1090 size = cellSizePtr(pPage, &temp[pc]);
1091 brk -= size;
1092 memcpy(&data[brk], &temp[pc], size);
1093 put2byte(pAddr, brk);
drh2af926b2001-05-15 00:39:25 +00001094 }
drh43605152004-05-29 21:46:49 +00001095 assert( brk>=cellOffset+2*nCell );
1096 put2byte(&data[hdr+5], brk);
1097 data[hdr+1] = 0;
1098 data[hdr+2] = 0;
1099 data[hdr+7] = 0;
1100 addr = cellOffset+2*nCell;
1101 memset(&data[addr], 0, brk-addr);
drh2e38c322004-09-03 18:38:44 +00001102 sqliteFree(temp);
1103 return SQLITE_OK;
drh365d68f2001-05-11 11:02:46 +00001104}
1105
drha059ad02001-04-17 20:09:11 +00001106/*
drh43605152004-05-29 21:46:49 +00001107** Allocate nByte bytes of space on a page.
drhbd03cae2001-06-02 02:40:57 +00001108**
drh9e572e62004-04-23 23:43:10 +00001109** Return the index into pPage->aData[] of the first byte of
drhbd03cae2001-06-02 02:40:57 +00001110** the new allocation. Or return 0 if there is not enough free
1111** space on the page to satisfy the allocation request.
drh2af926b2001-05-15 00:39:25 +00001112**
drh72f82862001-05-24 21:06:34 +00001113** If the page contains nBytes of free space but does not contain
drh8b2f49b2001-06-08 00:21:52 +00001114** nBytes of contiguous free space, then this routine automatically
1115** calls defragementPage() to consolidate all free space before
1116** allocating the new chunk.
drh7e3b0a02001-04-28 16:52:40 +00001117*/
drh9e572e62004-04-23 23:43:10 +00001118static int allocateSpace(MemPage *pPage, int nByte){
drh3aac2dd2004-04-26 14:10:20 +00001119 int addr, pc, hdr;
drh9e572e62004-04-23 23:43:10 +00001120 int size;
drh24cd67e2004-05-10 16:18:47 +00001121 int nFrag;
drh43605152004-05-29 21:46:49 +00001122 int top;
1123 int nCell;
1124 int cellOffset;
drh9e572e62004-04-23 23:43:10 +00001125 unsigned char *data;
drh43605152004-05-29 21:46:49 +00001126
drh9e572e62004-04-23 23:43:10 +00001127 data = pPage->aData;
drha34b6762004-05-07 13:30:42 +00001128 assert( sqlite3pager_iswriteable(data) );
drh9e572e62004-04-23 23:43:10 +00001129 assert( pPage->pBt );
1130 if( nByte<4 ) nByte = 4;
drh43605152004-05-29 21:46:49 +00001131 if( pPage->nFree<nByte || pPage->nOverflow>0 ) return 0;
1132 pPage->nFree -= nByte;
drh9e572e62004-04-23 23:43:10 +00001133 hdr = pPage->hdrOffset;
drh43605152004-05-29 21:46:49 +00001134
1135 nFrag = data[hdr+7];
1136 if( nFrag<60 ){
1137 /* Search the freelist looking for a slot big enough to satisfy the
1138 ** space request. */
1139 addr = hdr+1;
1140 while( (pc = get2byte(&data[addr]))>0 ){
1141 size = get2byte(&data[pc+2]);
1142 if( size>=nByte ){
1143 if( size<nByte+4 ){
1144 memcpy(&data[addr], &data[pc], 2);
1145 data[hdr+7] = nFrag + size - nByte;
1146 return pc;
1147 }else{
1148 put2byte(&data[pc+2], size-nByte);
1149 return pc + size - nByte;
1150 }
1151 }
1152 addr = pc;
drh9e572e62004-04-23 23:43:10 +00001153 }
1154 }
drh43605152004-05-29 21:46:49 +00001155
1156 /* Allocate memory from the gap in between the cell pointer array
1157 ** and the cell content area.
1158 */
1159 top = get2byte(&data[hdr+5]);
1160 nCell = get2byte(&data[hdr+3]);
1161 cellOffset = pPage->cellOffset;
1162 if( nFrag>=60 || cellOffset + 2*nCell > top - nByte ){
drh2e38c322004-09-03 18:38:44 +00001163 if( defragmentPage(pPage) ) return 0;
drh43605152004-05-29 21:46:49 +00001164 top = get2byte(&data[hdr+5]);
drh2af926b2001-05-15 00:39:25 +00001165 }
drh43605152004-05-29 21:46:49 +00001166 top -= nByte;
1167 assert( cellOffset + 2*nCell <= top );
1168 put2byte(&data[hdr+5], top);
1169 return top;
drh7e3b0a02001-04-28 16:52:40 +00001170}
1171
1172/*
drh9e572e62004-04-23 23:43:10 +00001173** Return a section of the pPage->aData to the freelist.
1174** The first byte of the new free block is pPage->aDisk[start]
1175** and the size of the block is "size" bytes.
drh306dc212001-05-21 13:45:10 +00001176**
1177** Most of the effort here is involved in coalesing adjacent
1178** free blocks into a single big free block.
drh7e3b0a02001-04-28 16:52:40 +00001179*/
drh9e572e62004-04-23 23:43:10 +00001180static void freeSpace(MemPage *pPage, int start, int size){
drh43605152004-05-29 21:46:49 +00001181 int addr, pbegin, hdr;
drh9e572e62004-04-23 23:43:10 +00001182 unsigned char *data = pPage->aData;
drh2af926b2001-05-15 00:39:25 +00001183
drh9e572e62004-04-23 23:43:10 +00001184 assert( pPage->pBt!=0 );
drha34b6762004-05-07 13:30:42 +00001185 assert( sqlite3pager_iswriteable(data) );
drh9e572e62004-04-23 23:43:10 +00001186 assert( start>=pPage->hdrOffset+6+(pPage->leaf?0:4) );
danielk1977bc6ada42004-06-30 08:20:16 +00001187 assert( (start + size)<=pPage->pBt->usableSize );
drh9e572e62004-04-23 23:43:10 +00001188 if( size<4 ) size = 4;
1189
drhfcce93f2006-02-22 03:08:32 +00001190#ifdef SQLITE_SECURE_DELETE
1191 /* Overwrite deleted information with zeros when the SECURE_DELETE
1192 ** option is enabled at compile-time */
1193 memset(&data[start], 0, size);
1194#endif
1195
drh9e572e62004-04-23 23:43:10 +00001196 /* Add the space back into the linked list of freeblocks */
drh43605152004-05-29 21:46:49 +00001197 hdr = pPage->hdrOffset;
1198 addr = hdr + 1;
drh3aac2dd2004-04-26 14:10:20 +00001199 while( (pbegin = get2byte(&data[addr]))<start && pbegin>0 ){
drhb6f41482004-05-14 01:58:11 +00001200 assert( pbegin<=pPage->pBt->usableSize-4 );
drh3aac2dd2004-04-26 14:10:20 +00001201 assert( pbegin>addr );
1202 addr = pbegin;
drh2af926b2001-05-15 00:39:25 +00001203 }
drhb6f41482004-05-14 01:58:11 +00001204 assert( pbegin<=pPage->pBt->usableSize-4 );
drh3aac2dd2004-04-26 14:10:20 +00001205 assert( pbegin>addr || pbegin==0 );
drha34b6762004-05-07 13:30:42 +00001206 put2byte(&data[addr], start);
1207 put2byte(&data[start], pbegin);
1208 put2byte(&data[start+2], size);
drh2af926b2001-05-15 00:39:25 +00001209 pPage->nFree += size;
drh9e572e62004-04-23 23:43:10 +00001210
1211 /* Coalesce adjacent free blocks */
drh3aac2dd2004-04-26 14:10:20 +00001212 addr = pPage->hdrOffset + 1;
1213 while( (pbegin = get2byte(&data[addr]))>0 ){
drh9e572e62004-04-23 23:43:10 +00001214 int pnext, psize;
drh3aac2dd2004-04-26 14:10:20 +00001215 assert( pbegin>addr );
drh43605152004-05-29 21:46:49 +00001216 assert( pbegin<=pPage->pBt->usableSize-4 );
drh9e572e62004-04-23 23:43:10 +00001217 pnext = get2byte(&data[pbegin]);
1218 psize = get2byte(&data[pbegin+2]);
1219 if( pbegin + psize + 3 >= pnext && pnext>0 ){
1220 int frag = pnext - (pbegin+psize);
drh43605152004-05-29 21:46:49 +00001221 assert( frag<=data[pPage->hdrOffset+7] );
1222 data[pPage->hdrOffset+7] -= frag;
drh9e572e62004-04-23 23:43:10 +00001223 put2byte(&data[pbegin], get2byte(&data[pnext]));
1224 put2byte(&data[pbegin+2], pnext+get2byte(&data[pnext+2])-pbegin);
1225 }else{
drh3aac2dd2004-04-26 14:10:20 +00001226 addr = pbegin;
drh9e572e62004-04-23 23:43:10 +00001227 }
1228 }
drh7e3b0a02001-04-28 16:52:40 +00001229
drh43605152004-05-29 21:46:49 +00001230 /* If the cell content area begins with a freeblock, remove it. */
1231 if( data[hdr+1]==data[hdr+5] && data[hdr+2]==data[hdr+6] ){
1232 int top;
1233 pbegin = get2byte(&data[hdr+1]);
1234 memcpy(&data[hdr+1], &data[pbegin], 2);
1235 top = get2byte(&data[hdr+5]);
1236 put2byte(&data[hdr+5], top + get2byte(&data[pbegin+2]));
drh4b70f112004-05-02 21:12:19 +00001237 }
drh4b70f112004-05-02 21:12:19 +00001238}
1239
1240/*
drh271efa52004-05-30 19:19:05 +00001241** Decode the flags byte (the first byte of the header) for a page
1242** and initialize fields of the MemPage structure accordingly.
1243*/
1244static void decodeFlags(MemPage *pPage, int flagByte){
danielk1977aef0bf62005-12-30 16:28:01 +00001245 BtShared *pBt; /* A copy of pPage->pBt */
drh271efa52004-05-30 19:19:05 +00001246
1247 assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
1248 pPage->intKey = (flagByte & (PTF_INTKEY|PTF_LEAFDATA))!=0;
1249 pPage->zeroData = (flagByte & PTF_ZERODATA)!=0;
1250 pPage->leaf = (flagByte & PTF_LEAF)!=0;
1251 pPage->childPtrSize = 4*(pPage->leaf==0);
1252 pBt = pPage->pBt;
1253 if( flagByte & PTF_LEAFDATA ){
1254 pPage->leafData = 1;
1255 pPage->maxLocal = pBt->maxLeaf;
1256 pPage->minLocal = pBt->minLeaf;
1257 }else{
1258 pPage->leafData = 0;
1259 pPage->maxLocal = pBt->maxLocal;
1260 pPage->minLocal = pBt->minLocal;
1261 }
1262 pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData));
1263}
1264
1265/*
drh7e3b0a02001-04-28 16:52:40 +00001266** Initialize the auxiliary information for a disk block.
drh72f82862001-05-24 21:06:34 +00001267**
drhbd03cae2001-06-02 02:40:57 +00001268** The pParent parameter must be a pointer to the MemPage which
drh9e572e62004-04-23 23:43:10 +00001269** is the parent of the page being initialized. The root of a
1270** BTree has no parent and so for that page, pParent==NULL.
drh5e2f8b92001-05-28 00:41:15 +00001271**
drh72f82862001-05-24 21:06:34 +00001272** Return SQLITE_OK on success. If we see that the page does
drhda47d772002-12-02 04:25:19 +00001273** not contain a well-formed database page, then return
drh72f82862001-05-24 21:06:34 +00001274** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not
1275** guarantee that the page is well-formed. It only shows that
1276** we failed to detect any corruption.
drh7e3b0a02001-04-28 16:52:40 +00001277*/
drh9e572e62004-04-23 23:43:10 +00001278static int initPage(
drh3aac2dd2004-04-26 14:10:20 +00001279 MemPage *pPage, /* The page to be initialized */
drh9e572e62004-04-23 23:43:10 +00001280 MemPage *pParent /* The parent. Might be NULL */
1281){
drh271efa52004-05-30 19:19:05 +00001282 int pc; /* Address of a freeblock within pPage->aData[] */
drh271efa52004-05-30 19:19:05 +00001283 int hdr; /* Offset to beginning of page header */
1284 u8 *data; /* Equal to pPage->aData */
danielk1977aef0bf62005-12-30 16:28:01 +00001285 BtShared *pBt; /* The main btree structure */
drh271efa52004-05-30 19:19:05 +00001286 int usableSize; /* Amount of usable space on each page */
1287 int cellOffset; /* Offset from start of page to first cell pointer */
1288 int nFree; /* Number of unused bytes on the page */
1289 int top; /* First byte of the cell content area */
drh2af926b2001-05-15 00:39:25 +00001290
drh2e38c322004-09-03 18:38:44 +00001291 pBt = pPage->pBt;
1292 assert( pBt!=0 );
1293 assert( pParent==0 || pParent->pBt==pBt );
drha34b6762004-05-07 13:30:42 +00001294 assert( pPage->pgno==sqlite3pager_pagenumber(pPage->aData) );
drh07d183d2005-05-01 22:52:42 +00001295 assert( pPage->aData == &((unsigned char*)pPage)[-pBt->pageSize] );
drhee696e22004-08-30 16:52:17 +00001296 if( pPage->pParent!=pParent && (pPage->pParent!=0 || pPage->isInit) ){
1297 /* The parent page should never change unless the file is corrupt */
drh49285702005-09-17 15:20:26 +00001298 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001299 }
drh10617cd2004-05-14 15:27:27 +00001300 if( pPage->isInit ) return SQLITE_OK;
drhda200cc2004-05-09 11:51:38 +00001301 if( pPage->pParent==0 && pParent!=0 ){
1302 pPage->pParent = pParent;
drha34b6762004-05-07 13:30:42 +00001303 sqlite3pager_ref(pParent->aData);
drh5e2f8b92001-05-28 00:41:15 +00001304 }
drhde647132004-05-07 17:57:49 +00001305 hdr = pPage->hdrOffset;
drha34b6762004-05-07 13:30:42 +00001306 data = pPage->aData;
drh271efa52004-05-30 19:19:05 +00001307 decodeFlags(pPage, data[hdr]);
drh43605152004-05-29 21:46:49 +00001308 pPage->nOverflow = 0;
drhc8629a12004-05-08 20:07:40 +00001309 pPage->idxShift = 0;
drh2e38c322004-09-03 18:38:44 +00001310 usableSize = pBt->usableSize;
drh43605152004-05-29 21:46:49 +00001311 pPage->cellOffset = cellOffset = hdr + 12 - 4*pPage->leaf;
1312 top = get2byte(&data[hdr+5]);
1313 pPage->nCell = get2byte(&data[hdr+3]);
drh2e38c322004-09-03 18:38:44 +00001314 if( pPage->nCell>MX_CELL(pBt) ){
drhee696e22004-08-30 16:52:17 +00001315 /* To many cells for a single page. The page must be corrupt */
drh49285702005-09-17 15:20:26 +00001316 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001317 }
1318 if( pPage->nCell==0 && pParent!=0 && pParent->pgno!=1 ){
1319 /* All pages must have at least one cell, except for root pages */
drh49285702005-09-17 15:20:26 +00001320 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001321 }
drh9e572e62004-04-23 23:43:10 +00001322
1323 /* Compute the total free space on the page */
drh9e572e62004-04-23 23:43:10 +00001324 pc = get2byte(&data[hdr+1]);
drh43605152004-05-29 21:46:49 +00001325 nFree = data[hdr+7] + top - (cellOffset + 2*pPage->nCell);
drh9e572e62004-04-23 23:43:10 +00001326 while( pc>0 ){
1327 int next, size;
drhee696e22004-08-30 16:52:17 +00001328 if( pc>usableSize-4 ){
1329 /* Free block is off the page */
drh49285702005-09-17 15:20:26 +00001330 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001331 }
drh9e572e62004-04-23 23:43:10 +00001332 next = get2byte(&data[pc]);
1333 size = get2byte(&data[pc+2]);
drhee696e22004-08-30 16:52:17 +00001334 if( next>0 && next<=pc+size+3 ){
1335 /* Free blocks must be in accending order */
drh49285702005-09-17 15:20:26 +00001336 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001337 }
drh3add3672004-05-15 00:29:24 +00001338 nFree += size;
drh9e572e62004-04-23 23:43:10 +00001339 pc = next;
1340 }
drh3add3672004-05-15 00:29:24 +00001341 pPage->nFree = nFree;
drhee696e22004-08-30 16:52:17 +00001342 if( nFree>=usableSize ){
1343 /* Free space cannot exceed total page size */
drh49285702005-09-17 15:20:26 +00001344 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001345 }
drh9e572e62004-04-23 23:43:10 +00001346
drhde647132004-05-07 17:57:49 +00001347 pPage->isInit = 1;
drh9e572e62004-04-23 23:43:10 +00001348 return SQLITE_OK;
drh7e3b0a02001-04-28 16:52:40 +00001349}
1350
1351/*
drh8b2f49b2001-06-08 00:21:52 +00001352** Set up a raw page so that it looks like a database page holding
1353** no entries.
drhbd03cae2001-06-02 02:40:57 +00001354*/
drh9e572e62004-04-23 23:43:10 +00001355static void zeroPage(MemPage *pPage, int flags){
1356 unsigned char *data = pPage->aData;
danielk1977aef0bf62005-12-30 16:28:01 +00001357 BtShared *pBt = pPage->pBt;
drh3aac2dd2004-04-26 14:10:20 +00001358 int hdr = pPage->hdrOffset;
drh9e572e62004-04-23 23:43:10 +00001359 int first;
1360
drhda200cc2004-05-09 11:51:38 +00001361 assert( sqlite3pager_pagenumber(data)==pPage->pgno );
drh07d183d2005-05-01 22:52:42 +00001362 assert( &data[pBt->pageSize] == (unsigned char*)pPage );
drha34b6762004-05-07 13:30:42 +00001363 assert( sqlite3pager_iswriteable(data) );
drhb6f41482004-05-14 01:58:11 +00001364 memset(&data[hdr], 0, pBt->usableSize - hdr);
drh9e572e62004-04-23 23:43:10 +00001365 data[hdr] = flags;
drh43605152004-05-29 21:46:49 +00001366 first = hdr + 8 + 4*((flags&PTF_LEAF)==0);
1367 memset(&data[hdr+1], 0, 4);
1368 data[hdr+7] = 0;
1369 put2byte(&data[hdr+5], pBt->usableSize);
drhb6f41482004-05-14 01:58:11 +00001370 pPage->nFree = pBt->usableSize - first;
drh271efa52004-05-30 19:19:05 +00001371 decodeFlags(pPage, flags);
drh9e572e62004-04-23 23:43:10 +00001372 pPage->hdrOffset = hdr;
drh43605152004-05-29 21:46:49 +00001373 pPage->cellOffset = first;
1374 pPage->nOverflow = 0;
drhda200cc2004-05-09 11:51:38 +00001375 pPage->idxShift = 0;
drh43605152004-05-29 21:46:49 +00001376 pPage->nCell = 0;
drhda200cc2004-05-09 11:51:38 +00001377 pPage->isInit = 1;
drhbd03cae2001-06-02 02:40:57 +00001378}
1379
1380/*
drh3aac2dd2004-04-26 14:10:20 +00001381** Get a page from the pager. Initialize the MemPage.pBt and
1382** MemPage.aData elements if needed.
1383*/
danielk1977aef0bf62005-12-30 16:28:01 +00001384static int getPage(BtShared *pBt, Pgno pgno, MemPage **ppPage){
drh3aac2dd2004-04-26 14:10:20 +00001385 int rc;
1386 unsigned char *aData;
1387 MemPage *pPage;
drha34b6762004-05-07 13:30:42 +00001388 rc = sqlite3pager_get(pBt->pPager, pgno, (void**)&aData);
drh3aac2dd2004-04-26 14:10:20 +00001389 if( rc ) return rc;
drh07d183d2005-05-01 22:52:42 +00001390 pPage = (MemPage*)&aData[pBt->pageSize];
drh3aac2dd2004-04-26 14:10:20 +00001391 pPage->aData = aData;
1392 pPage->pBt = pBt;
1393 pPage->pgno = pgno;
drhde647132004-05-07 17:57:49 +00001394 pPage->hdrOffset = pPage->pgno==1 ? 100 : 0;
drh3aac2dd2004-04-26 14:10:20 +00001395 *ppPage = pPage;
1396 return SQLITE_OK;
1397}
1398
1399/*
drhde647132004-05-07 17:57:49 +00001400** Get a page from the pager and initialize it. This routine
1401** is just a convenience wrapper around separate calls to
1402** getPage() and initPage().
1403*/
1404static int getAndInitPage(
danielk1977aef0bf62005-12-30 16:28:01 +00001405 BtShared *pBt, /* The database file */
drhde647132004-05-07 17:57:49 +00001406 Pgno pgno, /* Number of the page to get */
1407 MemPage **ppPage, /* Write the page pointer here */
1408 MemPage *pParent /* Parent of the page */
1409){
1410 int rc;
drhee696e22004-08-30 16:52:17 +00001411 if( pgno==0 ){
drh49285702005-09-17 15:20:26 +00001412 return SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00001413 }
drhde647132004-05-07 17:57:49 +00001414 rc = getPage(pBt, pgno, ppPage);
drh10617cd2004-05-14 15:27:27 +00001415 if( rc==SQLITE_OK && (*ppPage)->isInit==0 ){
drhde647132004-05-07 17:57:49 +00001416 rc = initPage(*ppPage, pParent);
1417 }
1418 return rc;
1419}
1420
1421/*
drh3aac2dd2004-04-26 14:10:20 +00001422** Release a MemPage. This should be called once for each prior
1423** call to getPage.
1424*/
drh4b70f112004-05-02 21:12:19 +00001425static void releasePage(MemPage *pPage){
drh3aac2dd2004-04-26 14:10:20 +00001426 if( pPage ){
1427 assert( pPage->aData );
1428 assert( pPage->pBt );
drh07d183d2005-05-01 22:52:42 +00001429 assert( &pPage->aData[pPage->pBt->pageSize]==(unsigned char*)pPage );
drha34b6762004-05-07 13:30:42 +00001430 sqlite3pager_unref(pPage->aData);
drh3aac2dd2004-04-26 14:10:20 +00001431 }
1432}
1433
1434/*
drh72f82862001-05-24 21:06:34 +00001435** This routine is called when the reference count for a page
1436** reaches zero. We need to unref the pParent pointer when that
1437** happens.
1438*/
drhb6f41482004-05-14 01:58:11 +00001439static void pageDestructor(void *pData, int pageSize){
drh07d183d2005-05-01 22:52:42 +00001440 MemPage *pPage;
1441 assert( (pageSize & 7)==0 );
1442 pPage = (MemPage*)&((char*)pData)[pageSize];
drh72f82862001-05-24 21:06:34 +00001443 if( pPage->pParent ){
1444 MemPage *pParent = pPage->pParent;
1445 pPage->pParent = 0;
drha34b6762004-05-07 13:30:42 +00001446 releasePage(pParent);
drh72f82862001-05-24 21:06:34 +00001447 }
drh3aac2dd2004-04-26 14:10:20 +00001448 pPage->isInit = 0;
drh72f82862001-05-24 21:06:34 +00001449}
1450
1451/*
drha6abd042004-06-09 17:37:22 +00001452** During a rollback, when the pager reloads information into the cache
1453** so that the cache is restored to its original state at the start of
1454** the transaction, for each page restored this routine is called.
1455**
1456** This routine needs to reset the extra data section at the end of the
1457** page to agree with the restored data.
1458*/
1459static void pageReinit(void *pData, int pageSize){
drh07d183d2005-05-01 22:52:42 +00001460 MemPage *pPage;
1461 assert( (pageSize & 7)==0 );
1462 pPage = (MemPage*)&((char*)pData)[pageSize];
drha6abd042004-06-09 17:37:22 +00001463 if( pPage->isInit ){
1464 pPage->isInit = 0;
1465 initPage(pPage, pPage->pParent);
1466 }
1467}
1468
1469/*
drhad3e0102004-09-03 23:32:18 +00001470** Open a database file.
1471**
drh382c0242001-10-06 16:33:02 +00001472** zFilename is the name of the database file. If zFilename is NULL
drh1bee3d72001-10-15 00:44:35 +00001473** a new database with a random name is created. This randomly named
drh23e11ca2004-05-04 17:27:28 +00001474** database file will be deleted when sqlite3BtreeClose() is called.
drha059ad02001-04-17 20:09:11 +00001475*/
drh23e11ca2004-05-04 17:27:28 +00001476int sqlite3BtreeOpen(
drh3aac2dd2004-04-26 14:10:20 +00001477 const char *zFilename, /* Name of the file containing the BTree database */
danielk1977aef0bf62005-12-30 16:28:01 +00001478 sqlite3 *pSqlite, /* Associated database handle */
drh3aac2dd2004-04-26 14:10:20 +00001479 Btree **ppBtree, /* Pointer to new Btree object written here */
drh90f5ecb2004-07-22 01:19:35 +00001480 int flags /* Options */
drh6019e162001-07-02 17:51:45 +00001481){
danielk1977aef0bf62005-12-30 16:28:01 +00001482 BtShared *pBt; /* Shared part of btree structure */
1483 Btree *p; /* Handle to return */
drha34b6762004-05-07 13:30:42 +00001484 int rc;
drh90f5ecb2004-07-22 01:19:35 +00001485 int nReserve;
1486 unsigned char zDbHeader[100];
drh6f7adc82006-01-11 21:41:20 +00001487#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
1488 const ThreadData *pTsdro;
danielk1977da184232006-01-05 11:34:32 +00001489#endif
danielk1977aef0bf62005-12-30 16:28:01 +00001490
1491 /* Set the variable isMemdb to true for an in-memory database, or
1492 ** false for a file-based database. This symbol is only required if
1493 ** either of the shared-data or autovacuum features are compiled
1494 ** into the library.
1495 */
1496#if !defined(SQLITE_OMIT_SHARED_CACHE) || !defined(SQLITE_OMIT_AUTOVACUUM)
1497 #ifdef SQLITE_OMIT_MEMORYDB
drh980b1a72006-08-16 16:42:48 +00001498 const int isMemdb = 0;
danielk1977aef0bf62005-12-30 16:28:01 +00001499 #else
drh980b1a72006-08-16 16:42:48 +00001500 const int isMemdb = zFilename && !strcmp(zFilename, ":memory:");
danielk1977aef0bf62005-12-30 16:28:01 +00001501 #endif
1502#endif
1503
1504 p = sqliteMalloc(sizeof(Btree));
1505 if( !p ){
1506 return SQLITE_NOMEM;
1507 }
1508 p->inTrans = TRANS_NONE;
1509 p->pSqlite = pSqlite;
1510
1511 /* Try to find an existing Btree structure opened on zFilename. */
drh198bf392006-01-06 21:52:49 +00001512#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
drh6f7adc82006-01-11 21:41:20 +00001513 pTsdro = sqlite3ThreadDataReadOnly();
1514 if( pTsdro->useSharedData && zFilename && !isMemdb ){
drh66560ad2006-01-06 14:32:19 +00001515 char *zFullPathname = sqlite3OsFullPathname(zFilename);
danielk1977aef0bf62005-12-30 16:28:01 +00001516 if( !zFullPathname ){
1517 sqliteFree(p);
1518 return SQLITE_NOMEM;
1519 }
drh6f7adc82006-01-11 21:41:20 +00001520 for(pBt=pTsdro->pBtree; pBt; pBt=pBt->pNext){
danielk1977b82e7ed2006-01-11 14:09:31 +00001521 assert( pBt->nRef>0 );
danielk1977aef0bf62005-12-30 16:28:01 +00001522 if( 0==strcmp(zFullPathname, sqlite3pager_filename(pBt->pPager)) ){
1523 p->pBt = pBt;
1524 *ppBtree = p;
1525 pBt->nRef++;
1526 sqliteFree(zFullPathname);
1527 return SQLITE_OK;
1528 }
1529 }
1530 sqliteFree(zFullPathname);
1531 }
1532#endif
drha059ad02001-04-17 20:09:11 +00001533
drhd62d3d02003-01-24 12:14:20 +00001534 /*
1535 ** The following asserts make sure that structures used by the btree are
1536 ** the right size. This is to guard against size changes that result
1537 ** when compiling on a different architecture.
1538 */
drh9b8f4472006-04-04 01:54:55 +00001539 assert( sizeof(i64)==8 || sizeof(i64)==4 );
1540 assert( sizeof(u64)==8 || sizeof(u64)==4 );
drhd62d3d02003-01-24 12:14:20 +00001541 assert( sizeof(u32)==4 );
1542 assert( sizeof(u16)==2 );
1543 assert( sizeof(Pgno)==4 );
drhd62d3d02003-01-24 12:14:20 +00001544
drha059ad02001-04-17 20:09:11 +00001545 pBt = sqliteMalloc( sizeof(*pBt) );
1546 if( pBt==0 ){
drh8c42ca92001-06-22 19:15:00 +00001547 *ppBtree = 0;
danielk1977aef0bf62005-12-30 16:28:01 +00001548 sqliteFree(p);
drha059ad02001-04-17 20:09:11 +00001549 return SQLITE_NOMEM;
1550 }
drh7bec5052005-02-06 02:45:41 +00001551 rc = sqlite3pager_open(&pBt->pPager, zFilename, EXTRA_SIZE, flags);
drh551b7732006-11-06 21:20:25 +00001552 if( rc==SQLITE_OK ){
1553 rc = sqlite3pager_read_fileheader(pBt->pPager,sizeof(zDbHeader),zDbHeader);
1554 }
drha059ad02001-04-17 20:09:11 +00001555 if( rc!=SQLITE_OK ){
drh551b7732006-11-06 21:20:25 +00001556 if( pBt->pPager ){
1557 sqlite3pager_close(pBt->pPager);
1558 }
drha059ad02001-04-17 20:09:11 +00001559 sqliteFree(pBt);
danielk1977aef0bf62005-12-30 16:28:01 +00001560 sqliteFree(p);
drha059ad02001-04-17 20:09:11 +00001561 *ppBtree = 0;
1562 return rc;
1563 }
danielk1977aef0bf62005-12-30 16:28:01 +00001564 p->pBt = pBt;
1565
drha34b6762004-05-07 13:30:42 +00001566 sqlite3pager_set_destructor(pBt->pPager, pageDestructor);
drha6abd042004-06-09 17:37:22 +00001567 sqlite3pager_set_reiniter(pBt->pPager, pageReinit);
drha059ad02001-04-17 20:09:11 +00001568 pBt->pCursor = 0;
drha34b6762004-05-07 13:30:42 +00001569 pBt->pPage1 = 0;
1570 pBt->readOnly = sqlite3pager_isreadonly(pBt->pPager);
drh90f5ecb2004-07-22 01:19:35 +00001571 pBt->pageSize = get2byte(&zDbHeader[16]);
drh07d183d2005-05-01 22:52:42 +00001572 if( pBt->pageSize<512 || pBt->pageSize>SQLITE_MAX_PAGE_SIZE
1573 || ((pBt->pageSize-1)&pBt->pageSize)!=0 ){
drh90f5ecb2004-07-22 01:19:35 +00001574 pBt->pageSize = SQLITE_DEFAULT_PAGE_SIZE;
1575 pBt->maxEmbedFrac = 64; /* 25% */
1576 pBt->minEmbedFrac = 32; /* 12.5% */
1577 pBt->minLeafFrac = 32; /* 12.5% */
drheee46cf2004-11-06 00:02:48 +00001578#ifndef SQLITE_OMIT_AUTOVACUUM
danielk197703aded42004-11-22 05:26:27 +00001579 /* If the magic name ":memory:" will create an in-memory database, then
1580 ** do not set the auto-vacuum flag, even if SQLITE_DEFAULT_AUTOVACUUM
1581 ** is true. On the other hand, if SQLITE_OMIT_MEMORYDB has been defined,
1582 ** then ":memory:" is just a regular file-name. Respect the auto-vacuum
1583 ** default in this case.
1584 */
danielk1977aef0bf62005-12-30 16:28:01 +00001585 if( zFilename && !isMemdb ){
danielk1977951af802004-11-05 15:45:09 +00001586 pBt->autoVacuum = SQLITE_DEFAULT_AUTOVACUUM;
1587 }
drheee46cf2004-11-06 00:02:48 +00001588#endif
drh90f5ecb2004-07-22 01:19:35 +00001589 nReserve = 0;
1590 }else{
1591 nReserve = zDbHeader[20];
1592 pBt->maxEmbedFrac = zDbHeader[21];
1593 pBt->minEmbedFrac = zDbHeader[22];
1594 pBt->minLeafFrac = zDbHeader[23];
1595 pBt->pageSizeFixed = 1;
danielk1977951af802004-11-05 15:45:09 +00001596#ifndef SQLITE_OMIT_AUTOVACUUM
1597 pBt->autoVacuum = (get4byte(&zDbHeader[36 + 4*4])?1:0);
1598#endif
drh90f5ecb2004-07-22 01:19:35 +00001599 }
1600 pBt->usableSize = pBt->pageSize - nReserve;
drh07d183d2005-05-01 22:52:42 +00001601 assert( (pBt->pageSize & 7)==0 ); /* 8-byte alignment of pageSize */
drh90f5ecb2004-07-22 01:19:35 +00001602 sqlite3pager_set_pagesize(pBt->pPager, pBt->pageSize);
danielk1977aef0bf62005-12-30 16:28:01 +00001603
drhcfed7bc2006-03-13 14:28:05 +00001604#if !defined(SQLITE_OMIT_SHARED_CACHE) && !defined(SQLITE_OMIT_DISKIO)
danielk197754f01982006-01-18 15:25:17 +00001605 /* Add the new btree to the linked list starting at ThreadData.pBtree.
1606 ** There is no chance that a malloc() may fail inside of the
1607 ** sqlite3ThreadData() call, as the ThreadData structure must have already
1608 ** been allocated for pTsdro->useSharedData to be non-zero.
1609 */
drh6f7adc82006-01-11 21:41:20 +00001610 if( pTsdro->useSharedData && zFilename && !isMemdb ){
1611 pBt->pNext = pTsdro->pBtree;
1612 sqlite3ThreadData()->pBtree = pBt;
danielk1977aef0bf62005-12-30 16:28:01 +00001613 }
danielk1977aef0bf62005-12-30 16:28:01 +00001614#endif
danielk1977da184232006-01-05 11:34:32 +00001615 pBt->nRef = 1;
danielk1977aef0bf62005-12-30 16:28:01 +00001616 *ppBtree = p;
drha059ad02001-04-17 20:09:11 +00001617 return SQLITE_OK;
1618}
1619
1620/*
1621** Close an open database and invalidate all cursors.
1622*/
danielk1977aef0bf62005-12-30 16:28:01 +00001623int sqlite3BtreeClose(Btree *p){
danielk1977aef0bf62005-12-30 16:28:01 +00001624 BtShared *pBt = p->pBt;
1625 BtCursor *pCur;
1626
danielk1977da184232006-01-05 11:34:32 +00001627#ifndef SQLITE_OMIT_SHARED_CACHE
drh6f7adc82006-01-11 21:41:20 +00001628 ThreadData *pTsd;
danielk1977da184232006-01-05 11:34:32 +00001629#endif
1630
danielk1977aef0bf62005-12-30 16:28:01 +00001631 /* Close all cursors opened via this handle. */
1632 pCur = pBt->pCursor;
1633 while( pCur ){
1634 BtCursor *pTmp = pCur;
1635 pCur = pCur->pNext;
1636 if( pTmp->pBtree==p ){
1637 sqlite3BtreeCloseCursor(pTmp);
1638 }
drha059ad02001-04-17 20:09:11 +00001639 }
danielk1977aef0bf62005-12-30 16:28:01 +00001640
danielk19778d34dfd2006-01-24 16:37:57 +00001641 /* Rollback any active transaction and free the handle structure.
1642 ** The call to sqlite3BtreeRollback() drops any table-locks held by
1643 ** this handle.
1644 */
danielk1977b597f742006-01-15 11:39:18 +00001645 sqlite3BtreeRollback(p);
danielk1977aef0bf62005-12-30 16:28:01 +00001646 sqliteFree(p);
1647
1648#ifndef SQLITE_OMIT_SHARED_CACHE
1649 /* If there are still other outstanding references to the shared-btree
1650 ** structure, return now. The remainder of this procedure cleans
1651 ** up the shared-btree.
1652 */
1653 assert( pBt->nRef>0 );
1654 pBt->nRef--;
1655 if( pBt->nRef ){
1656 return SQLITE_OK;
1657 }
1658
danielk197754f01982006-01-18 15:25:17 +00001659 /* Remove the shared-btree from the thread wide list. Call
1660 ** ThreadDataReadOnly() and then cast away the const property of the
1661 ** pointer to avoid allocating thread data if it is not really required.
1662 */
1663 pTsd = (ThreadData *)sqlite3ThreadDataReadOnly();
danielk1977aef0bf62005-12-30 16:28:01 +00001664 if( pTsd->pBtree==pBt ){
danielk197754f01982006-01-18 15:25:17 +00001665 assert( pTsd==sqlite3ThreadData() );
danielk1977aef0bf62005-12-30 16:28:01 +00001666 pTsd->pBtree = pBt->pNext;
1667 }else{
1668 BtShared *pPrev;
drh74161702006-02-24 02:53:49 +00001669 for(pPrev=pTsd->pBtree; pPrev && pPrev->pNext!=pBt; pPrev=pPrev->pNext){}
danielk1977aef0bf62005-12-30 16:28:01 +00001670 if( pPrev ){
danielk197754f01982006-01-18 15:25:17 +00001671 assert( pTsd==sqlite3ThreadData() );
danielk1977aef0bf62005-12-30 16:28:01 +00001672 pPrev->pNext = pBt->pNext;
1673 }
1674 }
1675#endif
1676
1677 /* Close the pager and free the shared-btree structure */
1678 assert( !pBt->pCursor );
drha34b6762004-05-07 13:30:42 +00001679 sqlite3pager_close(pBt->pPager);
danielk1977da184232006-01-05 11:34:32 +00001680 if( pBt->xFreeSchema && pBt->pSchema ){
1681 pBt->xFreeSchema(pBt->pSchema);
1682 }
danielk1977de0fe3e2006-01-06 06:33:12 +00001683 sqliteFree(pBt->pSchema);
drha059ad02001-04-17 20:09:11 +00001684 sqliteFree(pBt);
1685 return SQLITE_OK;
1686}
1687
1688/*
drh90f5ecb2004-07-22 01:19:35 +00001689** Change the busy handler callback function.
1690*/
danielk1977aef0bf62005-12-30 16:28:01 +00001691int sqlite3BtreeSetBusyHandler(Btree *p, BusyHandler *pHandler){
1692 BtShared *pBt = p->pBt;
drhb8ef32c2005-03-14 02:01:49 +00001693 pBt->pBusyHandler = pHandler;
drh90f5ecb2004-07-22 01:19:35 +00001694 sqlite3pager_set_busyhandler(pBt->pPager, pHandler);
1695 return SQLITE_OK;
1696}
1697
1698/*
drhda47d772002-12-02 04:25:19 +00001699** Change the limit on the number of pages allowed in the cache.
drhcd61c282002-03-06 22:01:34 +00001700**
1701** The maximum number of cache pages is set to the absolute
1702** value of mxPage. If mxPage is negative, the pager will
1703** operate asynchronously - it will not stop to do fsync()s
1704** to insure data is written to the disk surface before
1705** continuing. Transactions still work if synchronous is off,
1706** and the database cannot be corrupted if this program
1707** crashes. But if the operating system crashes or there is
1708** an abrupt power failure when synchronous is off, the database
1709** could be left in an inconsistent and unrecoverable state.
1710** Synchronous is on by default so database corruption is not
1711** normally a worry.
drhf57b14a2001-09-14 18:54:08 +00001712*/
danielk1977aef0bf62005-12-30 16:28:01 +00001713int sqlite3BtreeSetCacheSize(Btree *p, int mxPage){
1714 BtShared *pBt = p->pBt;
drha34b6762004-05-07 13:30:42 +00001715 sqlite3pager_set_cachesize(pBt->pPager, mxPage);
drhf57b14a2001-09-14 18:54:08 +00001716 return SQLITE_OK;
1717}
1718
1719/*
drh973b6e32003-02-12 14:09:42 +00001720** Change the way data is synced to disk in order to increase or decrease
1721** how well the database resists damage due to OS crashes and power
1722** failures. Level 1 is the same as asynchronous (no syncs() occur and
1723** there is a high probability of damage) Level 2 is the default. There
1724** is a very low but non-zero probability of damage. Level 3 reduces the
1725** probability of damage to near zero but with a write performance reduction.
1726*/
danielk197793758c82005-01-21 08:13:14 +00001727#ifndef SQLITE_OMIT_PAGER_PRAGMAS
drhac530b12006-02-11 01:25:50 +00001728int sqlite3BtreeSetSafetyLevel(Btree *p, int level, int fullSync){
danielk1977aef0bf62005-12-30 16:28:01 +00001729 BtShared *pBt = p->pBt;
drhac530b12006-02-11 01:25:50 +00001730 sqlite3pager_set_safety_level(pBt->pPager, level, fullSync);
drh973b6e32003-02-12 14:09:42 +00001731 return SQLITE_OK;
1732}
danielk197793758c82005-01-21 08:13:14 +00001733#endif
drh973b6e32003-02-12 14:09:42 +00001734
drh2c8997b2005-08-27 16:36:48 +00001735/*
1736** Return TRUE if the given btree is set to safety level 1. In other
1737** words, return TRUE if no sync() occurs on the disk files.
1738*/
danielk1977aef0bf62005-12-30 16:28:01 +00001739int sqlite3BtreeSyncDisabled(Btree *p){
1740 BtShared *pBt = p->pBt;
drh2c8997b2005-08-27 16:36:48 +00001741 assert( pBt && pBt->pPager );
1742 return sqlite3pager_nosync(pBt->pPager);
1743}
1744
danielk1977576ec6b2005-01-21 11:55:25 +00001745#if !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM)
drh973b6e32003-02-12 14:09:42 +00001746/*
drh90f5ecb2004-07-22 01:19:35 +00001747** Change the default pages size and the number of reserved bytes per page.
drh06f50212004-11-02 14:24:33 +00001748**
1749** The page size must be a power of 2 between 512 and 65536. If the page
1750** size supplied does not meet this constraint then the page size is not
1751** changed.
1752**
1753** Page sizes are constrained to be a power of two so that the region
1754** of the database file used for locking (beginning at PENDING_BYTE,
1755** the first byte past the 1GB boundary, 0x40000000) needs to occur
1756** at the beginning of a page.
danielk197728129562005-01-11 10:25:06 +00001757**
1758** If parameter nReserve is less than zero, then the number of reserved
1759** bytes per page is left unchanged.
drh90f5ecb2004-07-22 01:19:35 +00001760*/
danielk1977aef0bf62005-12-30 16:28:01 +00001761int sqlite3BtreeSetPageSize(Btree *p, int pageSize, int nReserve){
1762 BtShared *pBt = p->pBt;
drh90f5ecb2004-07-22 01:19:35 +00001763 if( pBt->pageSizeFixed ){
1764 return SQLITE_READONLY;
1765 }
1766 if( nReserve<0 ){
1767 nReserve = pBt->pageSize - pBt->usableSize;
1768 }
drh06f50212004-11-02 14:24:33 +00001769 if( pageSize>=512 && pageSize<=SQLITE_MAX_PAGE_SIZE &&
1770 ((pageSize-1)&pageSize)==0 ){
drh07d183d2005-05-01 22:52:42 +00001771 assert( (pageSize & 7)==0 );
danielk1977aef0bf62005-12-30 16:28:01 +00001772 assert( !pBt->pPage1 && !pBt->pCursor );
drh1c7880e2005-05-20 20:01:55 +00001773 pBt->pageSize = sqlite3pager_set_pagesize(pBt->pPager, pageSize);
drh90f5ecb2004-07-22 01:19:35 +00001774 }
1775 pBt->usableSize = pBt->pageSize - nReserve;
1776 return SQLITE_OK;
1777}
1778
1779/*
1780** Return the currently defined page size
1781*/
danielk1977aef0bf62005-12-30 16:28:01 +00001782int sqlite3BtreeGetPageSize(Btree *p){
1783 return p->pBt->pageSize;
drh90f5ecb2004-07-22 01:19:35 +00001784}
danielk1977aef0bf62005-12-30 16:28:01 +00001785int sqlite3BtreeGetReserve(Btree *p){
1786 return p->pBt->pageSize - p->pBt->usableSize;
drh2011d5f2004-07-22 02:40:37 +00001787}
danielk1977576ec6b2005-01-21 11:55:25 +00001788#endif /* !defined(SQLITE_OMIT_PAGER_PRAGMAS) || !defined(SQLITE_OMIT_VACUUM) */
drh90f5ecb2004-07-22 01:19:35 +00001789
1790/*
danielk1977951af802004-11-05 15:45:09 +00001791** Change the 'auto-vacuum' property of the database. If the 'autoVacuum'
1792** parameter is non-zero, then auto-vacuum mode is enabled. If zero, it
1793** is disabled. The default value for the auto-vacuum property is
1794** determined by the SQLITE_DEFAULT_AUTOVACUUM macro.
1795*/
danielk1977aef0bf62005-12-30 16:28:01 +00001796int sqlite3BtreeSetAutoVacuum(Btree *p, int autoVacuum){
1797 BtShared *pBt = p->pBt;;
danielk1977951af802004-11-05 15:45:09 +00001798#ifdef SQLITE_OMIT_AUTOVACUUM
drheee46cf2004-11-06 00:02:48 +00001799 return SQLITE_READONLY;
danielk1977951af802004-11-05 15:45:09 +00001800#else
1801 if( pBt->pageSizeFixed ){
1802 return SQLITE_READONLY;
1803 }
1804 pBt->autoVacuum = (autoVacuum?1:0);
1805 return SQLITE_OK;
1806#endif
1807}
1808
1809/*
1810** Return the value of the 'auto-vacuum' property. If auto-vacuum is
1811** enabled 1 is returned. Otherwise 0.
1812*/
danielk1977aef0bf62005-12-30 16:28:01 +00001813int sqlite3BtreeGetAutoVacuum(Btree *p){
danielk1977951af802004-11-05 15:45:09 +00001814#ifdef SQLITE_OMIT_AUTOVACUUM
1815 return 0;
1816#else
danielk1977aef0bf62005-12-30 16:28:01 +00001817 return p->pBt->autoVacuum;
danielk1977951af802004-11-05 15:45:09 +00001818#endif
1819}
1820
1821
1822/*
drha34b6762004-05-07 13:30:42 +00001823** Get a reference to pPage1 of the database file. This will
drh306dc212001-05-21 13:45:10 +00001824** also acquire a readlock on that file.
1825**
1826** SQLITE_OK is returned on success. If the file is not a
1827** well-formed database file, then SQLITE_CORRUPT is returned.
1828** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM
1829** is returned if we run out of memory. SQLITE_PROTOCOL is returned
1830** if there is a locking protocol violation.
1831*/
danielk1977aef0bf62005-12-30 16:28:01 +00001832static int lockBtree(BtShared *pBt){
drh07d183d2005-05-01 22:52:42 +00001833 int rc, pageSize;
drh3aac2dd2004-04-26 14:10:20 +00001834 MemPage *pPage1;
drha34b6762004-05-07 13:30:42 +00001835 if( pBt->pPage1 ) return SQLITE_OK;
drh3aac2dd2004-04-26 14:10:20 +00001836 rc = getPage(pBt, 1, &pPage1);
drh306dc212001-05-21 13:45:10 +00001837 if( rc!=SQLITE_OK ) return rc;
drh3aac2dd2004-04-26 14:10:20 +00001838
drh306dc212001-05-21 13:45:10 +00001839
1840 /* Do some checking to help insure the file we opened really is
1841 ** a valid database file.
1842 */
drhb6f41482004-05-14 01:58:11 +00001843 rc = SQLITE_NOTADB;
drha34b6762004-05-07 13:30:42 +00001844 if( sqlite3pager_pagecount(pBt->pPager)>0 ){
drhb6f41482004-05-14 01:58:11 +00001845 u8 *page1 = pPage1->aData;
1846 if( memcmp(page1, zMagicHeader, 16)!=0 ){
drh72f82862001-05-24 21:06:34 +00001847 goto page1_init_failed;
drh306dc212001-05-21 13:45:10 +00001848 }
drhb6f41482004-05-14 01:58:11 +00001849 if( page1[18]>1 || page1[19]>1 ){
1850 goto page1_init_failed;
1851 }
drh07d183d2005-05-01 22:52:42 +00001852 pageSize = get2byte(&page1[16]);
1853 if( ((pageSize-1)&pageSize)!=0 ){
1854 goto page1_init_failed;
1855 }
1856 assert( (pageSize & 7)==0 );
1857 pBt->pageSize = pageSize;
1858 pBt->usableSize = pageSize - page1[20];
drhb6f41482004-05-14 01:58:11 +00001859 if( pBt->usableSize<500 ){
1860 goto page1_init_failed;
1861 }
1862 pBt->maxEmbedFrac = page1[21];
1863 pBt->minEmbedFrac = page1[22];
1864 pBt->minLeafFrac = page1[23];
drh057cd3a2005-02-15 16:23:02 +00001865#ifndef SQLITE_OMIT_AUTOVACUUM
1866 pBt->autoVacuum = (get4byte(&page1[36 + 4*4])?1:0);
1867#endif
drh306dc212001-05-21 13:45:10 +00001868 }
drhb6f41482004-05-14 01:58:11 +00001869
1870 /* maxLocal is the maximum amount of payload to store locally for
1871 ** a cell. Make sure it is small enough so that at least minFanout
1872 ** cells can will fit on one page. We assume a 10-byte page header.
1873 ** Besides the payload, the cell must store:
drh43605152004-05-29 21:46:49 +00001874 ** 2-byte pointer to the cell
drhb6f41482004-05-14 01:58:11 +00001875 ** 4-byte child pointer
1876 ** 9-byte nKey value
1877 ** 4-byte nData value
1878 ** 4-byte overflow page pointer
drh43605152004-05-29 21:46:49 +00001879 ** So a cell consists of a 2-byte poiner, a header which is as much as
1880 ** 17 bytes long, 0 to N bytes of payload, and an optional 4 byte overflow
1881 ** page pointer.
drhb6f41482004-05-14 01:58:11 +00001882 */
drh43605152004-05-29 21:46:49 +00001883 pBt->maxLocal = (pBt->usableSize-12)*pBt->maxEmbedFrac/255 - 23;
1884 pBt->minLocal = (pBt->usableSize-12)*pBt->minEmbedFrac/255 - 23;
1885 pBt->maxLeaf = pBt->usableSize - 35;
1886 pBt->minLeaf = (pBt->usableSize-12)*pBt->minLeafFrac/255 - 23;
drhb6f41482004-05-14 01:58:11 +00001887 if( pBt->minLocal>pBt->maxLocal || pBt->maxLocal<0 ){
1888 goto page1_init_failed;
1889 }
drh2e38c322004-09-03 18:38:44 +00001890 assert( pBt->maxLeaf + 23 <= MX_CELL_SIZE(pBt) );
drh3aac2dd2004-04-26 14:10:20 +00001891 pBt->pPage1 = pPage1;
drhb6f41482004-05-14 01:58:11 +00001892 return SQLITE_OK;
drh306dc212001-05-21 13:45:10 +00001893
drh72f82862001-05-24 21:06:34 +00001894page1_init_failed:
drh3aac2dd2004-04-26 14:10:20 +00001895 releasePage(pPage1);
1896 pBt->pPage1 = 0;
drh72f82862001-05-24 21:06:34 +00001897 return rc;
drh306dc212001-05-21 13:45:10 +00001898}
1899
1900/*
drhb8ef32c2005-03-14 02:01:49 +00001901** This routine works like lockBtree() except that it also invokes the
1902** busy callback if there is lock contention.
1903*/
danielk1977aef0bf62005-12-30 16:28:01 +00001904static int lockBtreeWithRetry(Btree *pRef){
drhb8ef32c2005-03-14 02:01:49 +00001905 int rc = SQLITE_OK;
danielk1977aef0bf62005-12-30 16:28:01 +00001906 if( pRef->inTrans==TRANS_NONE ){
1907 u8 inTransaction = pRef->pBt->inTransaction;
1908 btreeIntegrity(pRef);
1909 rc = sqlite3BtreeBeginTrans(pRef, 0);
1910 pRef->pBt->inTransaction = inTransaction;
1911 pRef->inTrans = TRANS_NONE;
1912 if( rc==SQLITE_OK ){
1913 pRef->pBt->nTransaction--;
1914 }
1915 btreeIntegrity(pRef);
drhb8ef32c2005-03-14 02:01:49 +00001916 }
1917 return rc;
1918}
1919
1920
1921/*
drhb8ca3072001-12-05 00:21:20 +00001922** If there are no outstanding cursors and we are not in the middle
1923** of a transaction but there is a read lock on the database, then
1924** this routine unrefs the first page of the database file which
1925** has the effect of releasing the read lock.
1926**
1927** If there are any outstanding cursors, this routine is a no-op.
1928**
1929** If there is a transaction in progress, this routine is a no-op.
1930*/
danielk1977aef0bf62005-12-30 16:28:01 +00001931static void unlockBtreeIfUnused(BtShared *pBt){
1932 if( pBt->inTransaction==TRANS_NONE && pBt->pCursor==0 && pBt->pPage1!=0 ){
drh51c6d962004-06-06 00:42:25 +00001933 if( pBt->pPage1->aData==0 ){
1934 MemPage *pPage = pBt->pPage1;
drh2646da72005-12-09 20:02:05 +00001935 pPage->aData = &((u8*)pPage)[-pBt->pageSize];
drh51c6d962004-06-06 00:42:25 +00001936 pPage->pBt = pBt;
1937 pPage->pgno = 1;
1938 }
drh3aac2dd2004-04-26 14:10:20 +00001939 releasePage(pBt->pPage1);
1940 pBt->pPage1 = 0;
drh3aac2dd2004-04-26 14:10:20 +00001941 pBt->inStmt = 0;
drhb8ca3072001-12-05 00:21:20 +00001942 }
1943}
1944
1945/*
drh9e572e62004-04-23 23:43:10 +00001946** Create a new database by initializing the first page of the
drh8c42ca92001-06-22 19:15:00 +00001947** file.
drh8b2f49b2001-06-08 00:21:52 +00001948*/
danielk1977aef0bf62005-12-30 16:28:01 +00001949static int newDatabase(BtShared *pBt){
drh9e572e62004-04-23 23:43:10 +00001950 MemPage *pP1;
1951 unsigned char *data;
drh8c42ca92001-06-22 19:15:00 +00001952 int rc;
drhde647132004-05-07 17:57:49 +00001953 if( sqlite3pager_pagecount(pBt->pPager)>0 ) return SQLITE_OK;
drh3aac2dd2004-04-26 14:10:20 +00001954 pP1 = pBt->pPage1;
drh9e572e62004-04-23 23:43:10 +00001955 assert( pP1!=0 );
1956 data = pP1->aData;
drha34b6762004-05-07 13:30:42 +00001957 rc = sqlite3pager_write(data);
drh8b2f49b2001-06-08 00:21:52 +00001958 if( rc ) return rc;
drh9e572e62004-04-23 23:43:10 +00001959 memcpy(data, zMagicHeader, sizeof(zMagicHeader));
1960 assert( sizeof(zMagicHeader)==16 );
drhb6f41482004-05-14 01:58:11 +00001961 put2byte(&data[16], pBt->pageSize);
drh9e572e62004-04-23 23:43:10 +00001962 data[18] = 1;
1963 data[19] = 1;
drhb6f41482004-05-14 01:58:11 +00001964 data[20] = pBt->pageSize - pBt->usableSize;
1965 data[21] = pBt->maxEmbedFrac;
1966 data[22] = pBt->minEmbedFrac;
1967 data[23] = pBt->minLeafFrac;
1968 memset(&data[24], 0, 100-24);
drhe6c43812004-05-14 12:17:46 +00001969 zeroPage(pP1, PTF_INTKEY|PTF_LEAF|PTF_LEAFDATA );
drhf2a611c2004-09-05 00:33:43 +00001970 pBt->pageSizeFixed = 1;
danielk1977003ba062004-11-04 02:57:33 +00001971#ifndef SQLITE_OMIT_AUTOVACUUM
1972 if( pBt->autoVacuum ){
1973 put4byte(&data[36 + 4*4], 1);
1974 }
1975#endif
drh8b2f49b2001-06-08 00:21:52 +00001976 return SQLITE_OK;
1977}
1978
1979/*
danielk1977ee5741e2004-05-31 10:01:34 +00001980** Attempt to start a new transaction. A write-transaction
drh684917c2004-10-05 02:41:42 +00001981** is started if the second argument is nonzero, otherwise a read-
1982** transaction. If the second argument is 2 or more and exclusive
1983** transaction is started, meaning that no other process is allowed
1984** to access the database. A preexisting transaction may not be
drhb8ef32c2005-03-14 02:01:49 +00001985** upgraded to exclusive by calling this routine a second time - the
drh684917c2004-10-05 02:41:42 +00001986** exclusivity flag only works for a new transaction.
drh8b2f49b2001-06-08 00:21:52 +00001987**
danielk1977ee5741e2004-05-31 10:01:34 +00001988** A write-transaction must be started before attempting any
1989** changes to the database. None of the following routines
1990** will work unless a transaction is started first:
drh8b2f49b2001-06-08 00:21:52 +00001991**
drh23e11ca2004-05-04 17:27:28 +00001992** sqlite3BtreeCreateTable()
1993** sqlite3BtreeCreateIndex()
1994** sqlite3BtreeClearTable()
1995** sqlite3BtreeDropTable()
1996** sqlite3BtreeInsert()
1997** sqlite3BtreeDelete()
1998** sqlite3BtreeUpdateMeta()
danielk197713adf8a2004-06-03 16:08:41 +00001999**
drhb8ef32c2005-03-14 02:01:49 +00002000** If an initial attempt to acquire the lock fails because of lock contention
2001** and the database was previously unlocked, then invoke the busy handler
2002** if there is one. But if there was previously a read-lock, do not
2003** invoke the busy handler - just return SQLITE_BUSY. SQLITE_BUSY is
2004** returned when there is already a read-lock in order to avoid a deadlock.
2005**
2006** Suppose there are two processes A and B. A has a read lock and B has
2007** a reserved lock. B tries to promote to exclusive but is blocked because
2008** of A's read lock. A tries to promote to reserved but is blocked by B.
2009** One or the other of the two processes must give way or there can be
2010** no progress. By returning SQLITE_BUSY and not invoking the busy callback
2011** when A already has a read lock, we encourage A to give up and let B
2012** proceed.
drha059ad02001-04-17 20:09:11 +00002013*/
danielk1977aef0bf62005-12-30 16:28:01 +00002014int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
2015 BtShared *pBt = p->pBt;
danielk1977ee5741e2004-05-31 10:01:34 +00002016 int rc = SQLITE_OK;
2017
danielk1977aef0bf62005-12-30 16:28:01 +00002018 btreeIntegrity(p);
2019
danielk1977ee5741e2004-05-31 10:01:34 +00002020 /* If the btree is already in a write-transaction, or it
2021 ** is already in a read-transaction and a read-transaction
2022 ** is requested, this is a no-op.
2023 */
danielk1977aef0bf62005-12-30 16:28:01 +00002024 if( p->inTrans==TRANS_WRITE || (p->inTrans==TRANS_READ && !wrflag) ){
danielk1977ee5741e2004-05-31 10:01:34 +00002025 return SQLITE_OK;
2026 }
drhb8ef32c2005-03-14 02:01:49 +00002027
2028 /* Write transactions are not possible on a read-only database */
danielk1977ee5741e2004-05-31 10:01:34 +00002029 if( pBt->readOnly && wrflag ){
2030 return SQLITE_READONLY;
2031 }
2032
danielk1977aef0bf62005-12-30 16:28:01 +00002033 /* If another database handle has already opened a write transaction
2034 ** on this shared-btree structure and a second write transaction is
2035 ** requested, return SQLITE_BUSY.
2036 */
2037 if( pBt->inTransaction==TRANS_WRITE && wrflag ){
2038 return SQLITE_BUSY;
2039 }
2040
drhb8ef32c2005-03-14 02:01:49 +00002041 do {
2042 if( pBt->pPage1==0 ){
2043 rc = lockBtree(pBt);
drh8c42ca92001-06-22 19:15:00 +00002044 }
drhb8ef32c2005-03-14 02:01:49 +00002045
2046 if( rc==SQLITE_OK && wrflag ){
2047 rc = sqlite3pager_begin(pBt->pPage1->aData, wrflag>1);
2048 if( rc==SQLITE_OK ){
2049 rc = newDatabase(pBt);
2050 }
2051 }
2052
2053 if( rc==SQLITE_OK ){
drhb8ef32c2005-03-14 02:01:49 +00002054 if( wrflag ) pBt->inStmt = 0;
2055 }else{
2056 unlockBtreeIfUnused(pBt);
2057 }
danielk1977aef0bf62005-12-30 16:28:01 +00002058 }while( rc==SQLITE_BUSY && pBt->inTransaction==TRANS_NONE &&
drha4afb652005-07-09 02:16:02 +00002059 sqlite3InvokeBusyHandler(pBt->pBusyHandler) );
danielk1977aef0bf62005-12-30 16:28:01 +00002060
2061 if( rc==SQLITE_OK ){
2062 if( p->inTrans==TRANS_NONE ){
2063 pBt->nTransaction++;
2064 }
2065 p->inTrans = (wrflag?TRANS_WRITE:TRANS_READ);
2066 if( p->inTrans>pBt->inTransaction ){
2067 pBt->inTransaction = p->inTrans;
2068 }
2069 }
2070
2071 btreeIntegrity(p);
drhb8ca3072001-12-05 00:21:20 +00002072 return rc;
drha059ad02001-04-17 20:09:11 +00002073}
2074
danielk1977687566d2004-11-02 12:56:41 +00002075#ifndef SQLITE_OMIT_AUTOVACUUM
2076
2077/*
2078** Set the pointer-map entries for all children of page pPage. Also, if
2079** pPage contains cells that point to overflow pages, set the pointer
2080** map entries for the overflow pages as well.
2081*/
2082static int setChildPtrmaps(MemPage *pPage){
2083 int i; /* Counter variable */
2084 int nCell; /* Number of cells in page pPage */
2085 int rc = SQLITE_OK; /* Return code */
danielk1977aef0bf62005-12-30 16:28:01 +00002086 BtShared *pBt = pPage->pBt;
danielk1977687566d2004-11-02 12:56:41 +00002087 int isInitOrig = pPage->isInit;
2088 Pgno pgno = pPage->pgno;
2089
2090 initPage(pPage, 0);
2091 nCell = pPage->nCell;
2092
2093 for(i=0; i<nCell; i++){
danielk1977687566d2004-11-02 12:56:41 +00002094 u8 *pCell = findCell(pPage, i);
2095
danielk197726836652005-01-17 01:33:13 +00002096 rc = ptrmapPutOvflPtr(pPage, pCell);
2097 if( rc!=SQLITE_OK ){
2098 goto set_child_ptrmaps_out;
danielk1977687566d2004-11-02 12:56:41 +00002099 }
danielk197726836652005-01-17 01:33:13 +00002100
danielk1977687566d2004-11-02 12:56:41 +00002101 if( !pPage->leaf ){
2102 Pgno childPgno = get4byte(pCell);
2103 rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno);
2104 if( rc!=SQLITE_OK ) goto set_child_ptrmaps_out;
2105 }
2106 }
2107
2108 if( !pPage->leaf ){
2109 Pgno childPgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
2110 rc = ptrmapPut(pBt, childPgno, PTRMAP_BTREE, pgno);
2111 }
2112
2113set_child_ptrmaps_out:
2114 pPage->isInit = isInitOrig;
2115 return rc;
2116}
2117
2118/*
2119** Somewhere on pPage, which is guarenteed to be a btree page, not an overflow
2120** page, is a pointer to page iFrom. Modify this pointer so that it points to
2121** iTo. Parameter eType describes the type of pointer to be modified, as
2122** follows:
2123**
2124** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
2125** page of pPage.
2126**
2127** PTRMAP_OVERFLOW1: pPage is a btree-page. The pointer points at an overflow
2128** page pointed to by one of the cells on pPage.
2129**
2130** PTRMAP_OVERFLOW2: pPage is an overflow-page. The pointer points at the next
2131** overflow page in the list.
2132*/
danielk1977fdb7cdb2005-01-17 02:12:18 +00002133static int modifyPagePointer(MemPage *pPage, Pgno iFrom, Pgno iTo, u8 eType){
danielk1977687566d2004-11-02 12:56:41 +00002134 if( eType==PTRMAP_OVERFLOW2 ){
danielk1977f78fc082004-11-02 14:40:32 +00002135 /* The pointer is always the first 4 bytes of the page in this case. */
danielk1977fdb7cdb2005-01-17 02:12:18 +00002136 if( get4byte(pPage->aData)!=iFrom ){
drh49285702005-09-17 15:20:26 +00002137 return SQLITE_CORRUPT_BKPT;
danielk1977fdb7cdb2005-01-17 02:12:18 +00002138 }
danielk1977f78fc082004-11-02 14:40:32 +00002139 put4byte(pPage->aData, iTo);
danielk1977687566d2004-11-02 12:56:41 +00002140 }else{
2141 int isInitOrig = pPage->isInit;
2142 int i;
2143 int nCell;
2144
2145 initPage(pPage, 0);
2146 nCell = pPage->nCell;
2147
danielk1977687566d2004-11-02 12:56:41 +00002148 for(i=0; i<nCell; i++){
2149 u8 *pCell = findCell(pPage, i);
2150 if( eType==PTRMAP_OVERFLOW1 ){
2151 CellInfo info;
2152 parseCellPtr(pPage, pCell, &info);
2153 if( info.iOverflow ){
2154 if( iFrom==get4byte(&pCell[info.iOverflow]) ){
2155 put4byte(&pCell[info.iOverflow], iTo);
2156 break;
2157 }
2158 }
2159 }else{
2160 if( get4byte(pCell)==iFrom ){
2161 put4byte(pCell, iTo);
2162 break;
2163 }
2164 }
2165 }
2166
2167 if( i==nCell ){
danielk1977fdb7cdb2005-01-17 02:12:18 +00002168 if( eType!=PTRMAP_BTREE ||
2169 get4byte(&pPage->aData[pPage->hdrOffset+8])!=iFrom ){
drh49285702005-09-17 15:20:26 +00002170 return SQLITE_CORRUPT_BKPT;
danielk1977fdb7cdb2005-01-17 02:12:18 +00002171 }
danielk1977687566d2004-11-02 12:56:41 +00002172 put4byte(&pPage->aData[pPage->hdrOffset+8], iTo);
2173 }
2174
2175 pPage->isInit = isInitOrig;
2176 }
danielk1977fdb7cdb2005-01-17 02:12:18 +00002177 return SQLITE_OK;
danielk1977687566d2004-11-02 12:56:41 +00002178}
2179
danielk1977003ba062004-11-04 02:57:33 +00002180
danielk19777701e812005-01-10 12:59:51 +00002181/*
2182** Move the open database page pDbPage to location iFreePage in the
2183** database. The pDbPage reference remains valid.
2184*/
danielk1977003ba062004-11-04 02:57:33 +00002185static int relocatePage(
danielk1977aef0bf62005-12-30 16:28:01 +00002186 BtShared *pBt, /* Btree */
danielk19777701e812005-01-10 12:59:51 +00002187 MemPage *pDbPage, /* Open page to move */
2188 u8 eType, /* Pointer map 'type' entry for pDbPage */
2189 Pgno iPtrPage, /* Pointer map 'page-no' entry for pDbPage */
2190 Pgno iFreePage /* The location to move pDbPage to */
danielk1977003ba062004-11-04 02:57:33 +00002191){
2192 MemPage *pPtrPage; /* The page that contains a pointer to pDbPage */
2193 Pgno iDbPage = pDbPage->pgno;
2194 Pager *pPager = pBt->pPager;
2195 int rc;
2196
danielk1977a0bf2652004-11-04 14:30:04 +00002197 assert( eType==PTRMAP_OVERFLOW2 || eType==PTRMAP_OVERFLOW1 ||
2198 eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE );
danielk1977003ba062004-11-04 02:57:33 +00002199
2200 /* Move page iDbPage from it's current location to page number iFreePage */
2201 TRACE(("AUTOVACUUM: Moving %d to free page %d (ptr page %d type %d)\n",
2202 iDbPage, iFreePage, iPtrPage, eType));
2203 rc = sqlite3pager_movepage(pPager, pDbPage->aData, iFreePage);
2204 if( rc!=SQLITE_OK ){
2205 return rc;
2206 }
2207 pDbPage->pgno = iFreePage;
2208
2209 /* If pDbPage was a btree-page, then it may have child pages and/or cells
2210 ** that point to overflow pages. The pointer map entries for all these
2211 ** pages need to be changed.
2212 **
2213 ** If pDbPage is an overflow page, then the first 4 bytes may store a
2214 ** pointer to a subsequent overflow page. If this is the case, then
2215 ** the pointer map needs to be updated for the subsequent overflow page.
2216 */
danielk1977a0bf2652004-11-04 14:30:04 +00002217 if( eType==PTRMAP_BTREE || eType==PTRMAP_ROOTPAGE ){
danielk1977003ba062004-11-04 02:57:33 +00002218 rc = setChildPtrmaps(pDbPage);
2219 if( rc!=SQLITE_OK ){
2220 return rc;
2221 }
2222 }else{
2223 Pgno nextOvfl = get4byte(pDbPage->aData);
2224 if( nextOvfl!=0 ){
danielk1977003ba062004-11-04 02:57:33 +00002225 rc = ptrmapPut(pBt, nextOvfl, PTRMAP_OVERFLOW2, iFreePage);
2226 if( rc!=SQLITE_OK ){
2227 return rc;
2228 }
2229 }
2230 }
2231
2232 /* Fix the database pointer on page iPtrPage that pointed at iDbPage so
2233 ** that it points at iFreePage. Also fix the pointer map entry for
2234 ** iPtrPage.
2235 */
danielk1977a0bf2652004-11-04 14:30:04 +00002236 if( eType!=PTRMAP_ROOTPAGE ){
2237 rc = getPage(pBt, iPtrPage, &pPtrPage);
2238 if( rc!=SQLITE_OK ){
2239 return rc;
2240 }
2241 rc = sqlite3pager_write(pPtrPage->aData);
2242 if( rc!=SQLITE_OK ){
2243 releasePage(pPtrPage);
2244 return rc;
2245 }
danielk1977fdb7cdb2005-01-17 02:12:18 +00002246 rc = modifyPagePointer(pPtrPage, iDbPage, iFreePage, eType);
danielk1977003ba062004-11-04 02:57:33 +00002247 releasePage(pPtrPage);
danielk1977fdb7cdb2005-01-17 02:12:18 +00002248 if( rc==SQLITE_OK ){
2249 rc = ptrmapPut(pBt, iFreePage, eType, iPtrPage);
2250 }
danielk1977003ba062004-11-04 02:57:33 +00002251 }
danielk1977003ba062004-11-04 02:57:33 +00002252 return rc;
2253}
2254
danielk1977687566d2004-11-02 12:56:41 +00002255/* Forward declaration required by autoVacuumCommit(). */
danielk1977aef0bf62005-12-30 16:28:01 +00002256static int allocatePage(BtShared *, MemPage **, Pgno *, Pgno, u8);
danielk1977687566d2004-11-02 12:56:41 +00002257
2258/*
2259** This routine is called prior to sqlite3pager_commit when a transaction
2260** is commited for an auto-vacuum database.
2261*/
danielk1977aef0bf62005-12-30 16:28:01 +00002262static int autoVacuumCommit(BtShared *pBt, Pgno *nTrunc){
danielk1977687566d2004-11-02 12:56:41 +00002263 Pager *pPager = pBt->pPager;
danielk1977e501b892006-01-09 06:29:47 +00002264 Pgno nFreeList; /* Number of pages remaining on the free-list. */
2265 int nPtrMap; /* Number of pointer-map pages deallocated */
2266 Pgno origSize; /* Pages in the database file */
2267 Pgno finSize; /* Pages in the database file after truncation */
2268 int rc; /* Return code */
danielk1977687566d2004-11-02 12:56:41 +00002269 u8 eType;
danielk1977a19df672004-11-03 11:37:07 +00002270 int pgsz = pBt->pageSize; /* Page size for this database */
danielk1977687566d2004-11-02 12:56:41 +00002271 Pgno iDbPage; /* The database page to move */
danielk1977687566d2004-11-02 12:56:41 +00002272 MemPage *pDbMemPage = 0; /* "" */
2273 Pgno iPtrPage; /* The page that contains a pointer to iDbPage */
danielk1977687566d2004-11-02 12:56:41 +00002274 Pgno iFreePage; /* The free-list page to move iDbPage to */
2275 MemPage *pFreeMemPage = 0; /* "" */
2276
2277#ifndef NDEBUG
drh0f7eb612006-08-08 13:51:43 +00002278 int nRef = sqlite3pager_refcount(pPager);
danielk1977687566d2004-11-02 12:56:41 +00002279#endif
2280
2281 assert( pBt->autoVacuum );
danielk1977266664d2006-02-10 08:24:21 +00002282 if( PTRMAP_ISPAGE(pBt, sqlite3pager_pagecount(pPager)) ){
drh49285702005-09-17 15:20:26 +00002283 return SQLITE_CORRUPT_BKPT;
danielk1977fdb7cdb2005-01-17 02:12:18 +00002284 }
danielk1977687566d2004-11-02 12:56:41 +00002285
2286 /* Figure out how many free-pages are in the database. If there are no
2287 ** free pages, then auto-vacuum is a no-op.
2288 */
2289 nFreeList = get4byte(&pBt->pPage1->aData[36]);
danielk1977a19df672004-11-03 11:37:07 +00002290 if( nFreeList==0 ){
danielk1977d761c0c2004-11-05 16:37:02 +00002291 *nTrunc = 0;
danielk1977a19df672004-11-03 11:37:07 +00002292 return SQLITE_OK;
2293 }
danielk1977687566d2004-11-02 12:56:41 +00002294
danielk1977266664d2006-02-10 08:24:21 +00002295 /* This block figures out how many pages there are in the database
2296 ** now (variable origSize), and how many there will be after the
2297 ** truncation (variable finSize).
2298 **
2299 ** The final size is the original size, less the number of free pages
2300 ** in the database, less any pointer-map pages that will no longer
2301 ** be required, less 1 if the pending-byte page was part of the database
2302 ** but is not after the truncation.
2303 **/
danielk1977a19df672004-11-03 11:37:07 +00002304 origSize = sqlite3pager_pagecount(pPager);
danielk1977266664d2006-02-10 08:24:21 +00002305 if( origSize==PENDING_BYTE_PAGE(pBt) ){
2306 origSize--;
2307 }
2308 nPtrMap = (nFreeList-origSize+PTRMAP_PAGENO(pBt, origSize)+pgsz/5)/(pgsz/5);
danielk1977a19df672004-11-03 11:37:07 +00002309 finSize = origSize - nFreeList - nPtrMap;
danielk1977266664d2006-02-10 08:24:21 +00002310 if( origSize>PENDING_BYTE_PAGE(pBt) && finSize<=PENDING_BYTE_PAGE(pBt) ){
danielk1977599fcba2004-11-08 07:13:13 +00002311 finSize--;
danielk1977266664d2006-02-10 08:24:21 +00002312 }
2313 while( PTRMAP_ISPAGE(pBt, finSize) || finSize==PENDING_BYTE_PAGE(pBt) ){
2314 finSize--;
danielk1977599fcba2004-11-08 07:13:13 +00002315 }
danielk1977a19df672004-11-03 11:37:07 +00002316 TRACE(("AUTOVACUUM: Begin (db size %d->%d)\n", origSize, finSize));
danielk1977687566d2004-11-02 12:56:41 +00002317
danielk1977a19df672004-11-03 11:37:07 +00002318 /* Variable 'finSize' will be the size of the file in pages after
danielk1977687566d2004-11-02 12:56:41 +00002319 ** the auto-vacuum has completed (the current file size minus the number
2320 ** of pages on the free list). Loop through the pages that lie beyond
2321 ** this mark, and if they are not already on the free list, move them
danielk1977a19df672004-11-03 11:37:07 +00002322 ** to a free page earlier in the file (somewhere before finSize).
danielk1977687566d2004-11-02 12:56:41 +00002323 */
danielk1977a19df672004-11-03 11:37:07 +00002324 for( iDbPage=finSize+1; iDbPage<=origSize; iDbPage++ ){
danielk1977599fcba2004-11-08 07:13:13 +00002325 /* If iDbPage is a pointer map page, or the pending-byte page, skip it. */
danielk1977266664d2006-02-10 08:24:21 +00002326 if( PTRMAP_ISPAGE(pBt, iDbPage) || iDbPage==PENDING_BYTE_PAGE(pBt) ){
danielk1977599fcba2004-11-08 07:13:13 +00002327 continue;
2328 }
2329
danielk1977687566d2004-11-02 12:56:41 +00002330 rc = ptrmapGet(pBt, iDbPage, &eType, &iPtrPage);
2331 if( rc!=SQLITE_OK ) goto autovacuum_out;
drhccae6022005-02-26 17:31:26 +00002332 if( eType==PTRMAP_ROOTPAGE ){
drh49285702005-09-17 15:20:26 +00002333 rc = SQLITE_CORRUPT_BKPT;
drhccae6022005-02-26 17:31:26 +00002334 goto autovacuum_out;
2335 }
danielk1977687566d2004-11-02 12:56:41 +00002336
danielk1977599fcba2004-11-08 07:13:13 +00002337 /* If iDbPage is free, do not swap it. */
2338 if( eType==PTRMAP_FREEPAGE ){
danielk1977687566d2004-11-02 12:56:41 +00002339 continue;
2340 }
2341 rc = getPage(pBt, iDbPage, &pDbMemPage);
2342 if( rc!=SQLITE_OK ) goto autovacuum_out;
danielk1977687566d2004-11-02 12:56:41 +00002343
2344 /* Find the next page in the free-list that is not already at the end
2345 ** of the file. A page can be pulled off the free list using the
2346 ** allocatePage() routine.
2347 */
2348 do{
2349 if( pFreeMemPage ){
2350 releasePage(pFreeMemPage);
2351 pFreeMemPage = 0;
2352 }
danielk1977cb1a7eb2004-11-05 12:27:02 +00002353 rc = allocatePage(pBt, &pFreeMemPage, &iFreePage, 0, 0);
danielk1977ac11ee62005-01-15 12:45:51 +00002354 if( rc!=SQLITE_OK ){
2355 releasePage(pDbMemPage);
2356 goto autovacuum_out;
2357 }
danielk1977a19df672004-11-03 11:37:07 +00002358 assert( iFreePage<=origSize );
2359 }while( iFreePage>finSize );
danielk1977687566d2004-11-02 12:56:41 +00002360 releasePage(pFreeMemPage);
2361 pFreeMemPage = 0;
danielk1977687566d2004-11-02 12:56:41 +00002362
danielk1977e501b892006-01-09 06:29:47 +00002363 /* Relocate the page into the body of the file. Note that although the
2364 ** page has moved within the database file, the pDbMemPage pointer
2365 ** remains valid. This means that this function can run without
2366 ** invalidating cursors open on the btree. This is important in
2367 ** shared-cache mode.
2368 */
danielk1977003ba062004-11-04 02:57:33 +00002369 rc = relocatePage(pBt, pDbMemPage, eType, iPtrPage, iFreePage);
danielk1977687566d2004-11-02 12:56:41 +00002370 releasePage(pDbMemPage);
danielk1977687566d2004-11-02 12:56:41 +00002371 if( rc!=SQLITE_OK ) goto autovacuum_out;
danielk1977687566d2004-11-02 12:56:41 +00002372 }
2373
2374 /* The entire free-list has been swapped to the end of the file. So
danielk1977a19df672004-11-03 11:37:07 +00002375 ** truncate the database file to finSize pages and consider the
danielk1977687566d2004-11-02 12:56:41 +00002376 ** free-list empty.
2377 */
2378 rc = sqlite3pager_write(pBt->pPage1->aData);
2379 if( rc!=SQLITE_OK ) goto autovacuum_out;
2380 put4byte(&pBt->pPage1->aData[32], 0);
2381 put4byte(&pBt->pPage1->aData[36], 0);
danielk1977d761c0c2004-11-05 16:37:02 +00002382 *nTrunc = finSize;
danielk1977266664d2006-02-10 08:24:21 +00002383 assert( finSize!=PENDING_BYTE_PAGE(pBt) );
danielk1977687566d2004-11-02 12:56:41 +00002384
2385autovacuum_out:
drh0f7eb612006-08-08 13:51:43 +00002386 assert( nRef==sqlite3pager_refcount(pPager) );
danielk1977687566d2004-11-02 12:56:41 +00002387 if( rc!=SQLITE_OK ){
2388 sqlite3pager_rollback(pPager);
2389 }
2390 return rc;
2391}
2392#endif
2393
2394/*
drh2aa679f2001-06-25 02:11:07 +00002395** Commit the transaction currently in progress.
drh5e00f6c2001-09-13 13:46:56 +00002396**
2397** This will release the write lock on the database file. If there
2398** are no active cursors, it also releases the read lock.
drha059ad02001-04-17 20:09:11 +00002399*/
danielk1977aef0bf62005-12-30 16:28:01 +00002400int sqlite3BtreeCommit(Btree *p){
danielk1977aef0bf62005-12-30 16:28:01 +00002401 BtShared *pBt = p->pBt;
2402
2403 btreeIntegrity(p);
danielk1977aef0bf62005-12-30 16:28:01 +00002404
2405 /* If the handle has a write-transaction open, commit the shared-btrees
2406 ** transaction and set the shared state to TRANS_READ.
2407 */
2408 if( p->inTrans==TRANS_WRITE ){
danielk19777f7bc662006-01-23 13:47:47 +00002409 int rc;
danielk1977aef0bf62005-12-30 16:28:01 +00002410 assert( pBt->inTransaction==TRANS_WRITE );
2411 assert( pBt->nTransaction>0 );
danielk1977ee5741e2004-05-31 10:01:34 +00002412 rc = sqlite3pager_commit(pBt->pPager);
danielk19777f7bc662006-01-23 13:47:47 +00002413 if( rc!=SQLITE_OK ){
2414 return rc;
2415 }
danielk1977aef0bf62005-12-30 16:28:01 +00002416 pBt->inTransaction = TRANS_READ;
2417 pBt->inStmt = 0;
danielk1977ee5741e2004-05-31 10:01:34 +00002418 }
danielk19777f7bc662006-01-23 13:47:47 +00002419 unlockAllTables(p);
danielk1977aef0bf62005-12-30 16:28:01 +00002420
2421 /* If the handle has any kind of transaction open, decrement the transaction
2422 ** count of the shared btree. If the transaction count reaches 0, set
2423 ** the shared state to TRANS_NONE. The unlockBtreeIfUnused() call below
2424 ** will unlock the pager.
2425 */
2426 if( p->inTrans!=TRANS_NONE ){
2427 pBt->nTransaction--;
2428 if( 0==pBt->nTransaction ){
2429 pBt->inTransaction = TRANS_NONE;
2430 }
2431 }
2432
2433 /* Set the handles current transaction state to TRANS_NONE and unlock
2434 ** the pager if this call closed the only read or write transaction.
2435 */
2436 p->inTrans = TRANS_NONE;
drh5e00f6c2001-09-13 13:46:56 +00002437 unlockBtreeIfUnused(pBt);
danielk1977aef0bf62005-12-30 16:28:01 +00002438
2439 btreeIntegrity(p);
danielk19777f7bc662006-01-23 13:47:47 +00002440 return SQLITE_OK;
drha059ad02001-04-17 20:09:11 +00002441}
2442
danielk1977fbcd5852004-06-15 02:44:18 +00002443#ifndef NDEBUG
2444/*
2445** Return the number of write-cursors open on this handle. This is for use
2446** in assert() expressions, so it is only compiled if NDEBUG is not
2447** defined.
2448*/
danielk1977aef0bf62005-12-30 16:28:01 +00002449static int countWriteCursors(BtShared *pBt){
danielk1977fbcd5852004-06-15 02:44:18 +00002450 BtCursor *pCur;
2451 int r = 0;
2452 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
danielk1977aef0bf62005-12-30 16:28:01 +00002453 if( pCur->wrFlag ) r++;
danielk1977fbcd5852004-06-15 02:44:18 +00002454 }
2455 return r;
2456}
2457#endif
2458
drh77bba592006-08-13 18:39:26 +00002459#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
drhda200cc2004-05-09 11:51:38 +00002460/*
2461** Print debugging information about all cursors to standard output.
2462*/
danielk1977aef0bf62005-12-30 16:28:01 +00002463void sqlite3BtreeCursorList(Btree *p){
drhda200cc2004-05-09 11:51:38 +00002464 BtCursor *pCur;
danielk1977aef0bf62005-12-30 16:28:01 +00002465 BtShared *pBt = p->pBt;
drhda200cc2004-05-09 11:51:38 +00002466 for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){
2467 MemPage *pPage = pCur->pPage;
2468 char *zMode = pCur->wrFlag ? "rw" : "ro";
drhfe63d1c2004-09-08 20:13:04 +00002469 sqlite3DebugPrintf("CURSOR %p rooted at %4d(%s) currently at %d.%d%s\n",
2470 pCur, pCur->pgnoRoot, zMode,
drhda200cc2004-05-09 11:51:38 +00002471 pPage ? pPage->pgno : 0, pCur->idx,
danielk1977da184232006-01-05 11:34:32 +00002472 (pCur->eState==CURSOR_VALID) ? "" : " eof"
drhda200cc2004-05-09 11:51:38 +00002473 );
2474 }
2475}
2476#endif
2477
drhc39e0002004-05-07 23:50:57 +00002478/*
drhecdc7532001-09-23 02:35:53 +00002479** Rollback the transaction in progress. All cursors will be
2480** invalided by this operation. Any attempt to use a cursor
2481** that was open at the beginning of this operation will result
2482** in an error.
drh5e00f6c2001-09-13 13:46:56 +00002483**
2484** This will release the write lock on the database file. If there
2485** are no active cursors, it also releases the read lock.
drha059ad02001-04-17 20:09:11 +00002486*/
danielk1977aef0bf62005-12-30 16:28:01 +00002487int sqlite3BtreeRollback(Btree *p){
danielk19778d34dfd2006-01-24 16:37:57 +00002488 int rc;
danielk1977aef0bf62005-12-30 16:28:01 +00002489 BtShared *pBt = p->pBt;
drh24cd67e2004-05-10 16:18:47 +00002490 MemPage *pPage1;
danielk1977aef0bf62005-12-30 16:28:01 +00002491
danielk19772b8c13e2006-01-24 14:21:24 +00002492 rc = saveAllCursors(pBt, 0, 0);
danielk19778d34dfd2006-01-24 16:37:57 +00002493#ifndef SQLITE_OMIT_SHARED_CACHE
danielk19772b8c13e2006-01-24 14:21:24 +00002494 if( rc!=SQLITE_OK ){
danielk19778d34dfd2006-01-24 16:37:57 +00002495 /* This is a horrible situation. An IO or malloc() error occured whilst
2496 ** trying to save cursor positions. If this is an automatic rollback (as
2497 ** the result of a constraint, malloc() failure or IO error) then
2498 ** the cache may be internally inconsistent (not contain valid trees) so
2499 ** we cannot simply return the error to the caller. Instead, abort
2500 ** all queries that may be using any of the cursors that failed to save.
2501 */
2502 while( pBt->pCursor ){
2503 sqlite3 *db = pBt->pCursor->pBtree->pSqlite;
2504 if( db ){
2505 sqlite3AbortOtherActiveVdbes(db, 0);
2506 }
2507 }
danielk19772b8c13e2006-01-24 14:21:24 +00002508 }
danielk19778d34dfd2006-01-24 16:37:57 +00002509#endif
danielk1977aef0bf62005-12-30 16:28:01 +00002510 btreeIntegrity(p);
2511 unlockAllTables(p);
2512
2513 if( p->inTrans==TRANS_WRITE ){
danielk19778d34dfd2006-01-24 16:37:57 +00002514 int rc2;
danielk1977aef0bf62005-12-30 16:28:01 +00002515
danielk19778d34dfd2006-01-24 16:37:57 +00002516 assert( TRANS_WRITE==pBt->inTransaction );
2517 rc2 = sqlite3pager_rollback(pBt->pPager);
2518 if( rc2!=SQLITE_OK ){
2519 rc = rc2;
2520 }
2521
drh24cd67e2004-05-10 16:18:47 +00002522 /* The rollback may have destroyed the pPage1->aData value. So
2523 ** call getPage() on page 1 again to make sure pPage1->aData is
2524 ** set correctly. */
2525 if( getPage(pBt, 1, &pPage1)==SQLITE_OK ){
2526 releasePage(pPage1);
2527 }
danielk1977fbcd5852004-06-15 02:44:18 +00002528 assert( countWriteCursors(pBt)==0 );
danielk1977aef0bf62005-12-30 16:28:01 +00002529 pBt->inTransaction = TRANS_READ;
drh24cd67e2004-05-10 16:18:47 +00002530 }
danielk1977aef0bf62005-12-30 16:28:01 +00002531
2532 if( p->inTrans!=TRANS_NONE ){
2533 assert( pBt->nTransaction>0 );
2534 pBt->nTransaction--;
2535 if( 0==pBt->nTransaction ){
2536 pBt->inTransaction = TRANS_NONE;
2537 }
2538 }
2539
2540 p->inTrans = TRANS_NONE;
danielk1977ee5741e2004-05-31 10:01:34 +00002541 pBt->inStmt = 0;
drh5e00f6c2001-09-13 13:46:56 +00002542 unlockBtreeIfUnused(pBt);
danielk1977aef0bf62005-12-30 16:28:01 +00002543
2544 btreeIntegrity(p);
drha059ad02001-04-17 20:09:11 +00002545 return rc;
2546}
2547
2548/*
drhab01f612004-05-22 02:55:23 +00002549** Start a statement subtransaction. The subtransaction can
2550** can be rolled back independently of the main transaction.
2551** You must start a transaction before starting a subtransaction.
2552** The subtransaction is ended automatically if the main transaction
drh663fc632002-02-02 18:49:19 +00002553** commits or rolls back.
2554**
drhab01f612004-05-22 02:55:23 +00002555** Only one subtransaction may be active at a time. It is an error to try
2556** to start a new subtransaction if another subtransaction is already active.
2557**
2558** Statement subtransactions are used around individual SQL statements
2559** that are contained within a BEGIN...COMMIT block. If a constraint
2560** error occurs within the statement, the effect of that one statement
2561** can be rolled back without having to rollback the entire transaction.
drh663fc632002-02-02 18:49:19 +00002562*/
danielk1977aef0bf62005-12-30 16:28:01 +00002563int sqlite3BtreeBeginStmt(Btree *p){
drh663fc632002-02-02 18:49:19 +00002564 int rc;
danielk1977aef0bf62005-12-30 16:28:01 +00002565 BtShared *pBt = p->pBt;
2566 if( (p->inTrans!=TRANS_WRITE) || pBt->inStmt ){
drhf74b8d92002-09-01 23:20:45 +00002567 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh0d65dc02002-02-03 00:56:09 +00002568 }
danielk1977aef0bf62005-12-30 16:28:01 +00002569 assert( pBt->inTransaction==TRANS_WRITE );
drha34b6762004-05-07 13:30:42 +00002570 rc = pBt->readOnly ? SQLITE_OK : sqlite3pager_stmt_begin(pBt->pPager);
drh3aac2dd2004-04-26 14:10:20 +00002571 pBt->inStmt = 1;
drh663fc632002-02-02 18:49:19 +00002572 return rc;
2573}
2574
2575
2576/*
drhab01f612004-05-22 02:55:23 +00002577** Commit the statment subtransaction currently in progress. If no
2578** subtransaction is active, this is a no-op.
drh663fc632002-02-02 18:49:19 +00002579*/
danielk1977aef0bf62005-12-30 16:28:01 +00002580int sqlite3BtreeCommitStmt(Btree *p){
drh663fc632002-02-02 18:49:19 +00002581 int rc;
danielk1977aef0bf62005-12-30 16:28:01 +00002582 BtShared *pBt = p->pBt;
drh3aac2dd2004-04-26 14:10:20 +00002583 if( pBt->inStmt && !pBt->readOnly ){
drha34b6762004-05-07 13:30:42 +00002584 rc = sqlite3pager_stmt_commit(pBt->pPager);
drh663fc632002-02-02 18:49:19 +00002585 }else{
2586 rc = SQLITE_OK;
2587 }
drh3aac2dd2004-04-26 14:10:20 +00002588 pBt->inStmt = 0;
drh663fc632002-02-02 18:49:19 +00002589 return rc;
2590}
2591
2592/*
drhab01f612004-05-22 02:55:23 +00002593** Rollback the active statement subtransaction. If no subtransaction
2594** is active this routine is a no-op.
drh663fc632002-02-02 18:49:19 +00002595**
drhab01f612004-05-22 02:55:23 +00002596** All cursors will be invalidated by this operation. Any attempt
drh663fc632002-02-02 18:49:19 +00002597** to use a cursor that was open at the beginning of this operation
2598** will result in an error.
2599*/
danielk1977aef0bf62005-12-30 16:28:01 +00002600int sqlite3BtreeRollbackStmt(Btree *p){
danielk197797a227c2006-01-20 16:32:04 +00002601 int rc = SQLITE_OK;
danielk1977aef0bf62005-12-30 16:28:01 +00002602 BtShared *pBt = p->pBt;
danielk197797a227c2006-01-20 16:32:04 +00002603 sqlite3MallocDisallow();
2604 if( pBt->inStmt && !pBt->readOnly ){
2605 rc = sqlite3pager_stmt_rollback(pBt->pPager);
2606 assert( countWriteCursors(pBt)==0 );
2607 pBt->inStmt = 0;
2608 }
2609 sqlite3MallocAllow();
drh663fc632002-02-02 18:49:19 +00002610 return rc;
2611}
2612
2613/*
drh3aac2dd2004-04-26 14:10:20 +00002614** Default key comparison function to be used if no comparison function
2615** is specified on the sqlite3BtreeCursor() call.
2616*/
2617static int dfltCompare(
2618 void *NotUsed, /* User data is not used */
2619 int n1, const void *p1, /* First key to compare */
2620 int n2, const void *p2 /* Second key to compare */
2621){
2622 int c;
2623 c = memcmp(p1, p2, n1<n2 ? n1 : n2);
2624 if( c==0 ){
2625 c = n1 - n2;
2626 }
2627 return c;
2628}
2629
2630/*
drh8b2f49b2001-06-08 00:21:52 +00002631** Create a new cursor for the BTree whose root is on the page
2632** iTable. The act of acquiring a cursor gets a read lock on
2633** the database file.
drh1bee3d72001-10-15 00:44:35 +00002634**
2635** If wrFlag==0, then the cursor can only be used for reading.
drhf74b8d92002-09-01 23:20:45 +00002636** If wrFlag==1, then the cursor can be used for reading or for
2637** writing if other conditions for writing are also met. These
2638** are the conditions that must be met in order for writing to
2639** be allowed:
drh6446c4d2001-12-15 14:22:18 +00002640**
drhf74b8d92002-09-01 23:20:45 +00002641** 1: The cursor must have been opened with wrFlag==1
2642**
2643** 2: No other cursors may be open with wrFlag==0 on the same table
2644**
2645** 3: The database must be writable (not on read-only media)
2646**
2647** 4: There must be an active transaction.
2648**
2649** Condition 2 warrants further discussion. If any cursor is opened
2650** on a table with wrFlag==0, that prevents all other cursors from
2651** writing to that table. This is a kind of "read-lock". When a cursor
2652** is opened with wrFlag==0 it is guaranteed that the table will not
2653** change as long as the cursor is open. This allows the cursor to
2654** do a sequential scan of the table without having to worry about
2655** entries being inserted or deleted during the scan. Cursors should
2656** be opened with wrFlag==0 only if this read-lock property is needed.
2657** That is to say, cursors should be opened with wrFlag==0 only if they
drh23e11ca2004-05-04 17:27:28 +00002658** intend to use the sqlite3BtreeNext() system call. All other cursors
drhf74b8d92002-09-01 23:20:45 +00002659** should be opened with wrFlag==1 even if they never really intend
2660** to write.
2661**
drh6446c4d2001-12-15 14:22:18 +00002662** No checking is done to make sure that page iTable really is the
2663** root page of a b-tree. If it is not, then the cursor acquired
2664** will not work correctly.
drh3aac2dd2004-04-26 14:10:20 +00002665**
2666** The comparison function must be logically the same for every cursor
2667** on a particular table. Changing the comparison function will result
2668** in incorrect operations. If the comparison function is NULL, a
2669** default comparison function is used. The comparison function is
2670** always ignored for INTKEY tables.
drha059ad02001-04-17 20:09:11 +00002671*/
drh3aac2dd2004-04-26 14:10:20 +00002672int sqlite3BtreeCursor(
danielk1977aef0bf62005-12-30 16:28:01 +00002673 Btree *p, /* The btree */
drh3aac2dd2004-04-26 14:10:20 +00002674 int iTable, /* Root page of table to open */
2675 int wrFlag, /* 1 to write. 0 read-only */
2676 int (*xCmp)(void*,int,const void*,int,const void*), /* Key Comparison func */
2677 void *pArg, /* First arg to xCompare() */
2678 BtCursor **ppCur /* Write new cursor here */
2679){
drha059ad02001-04-17 20:09:11 +00002680 int rc;
drh8dcd7ca2004-08-08 19:43:29 +00002681 BtCursor *pCur;
danielk1977aef0bf62005-12-30 16:28:01 +00002682 BtShared *pBt = p->pBt;
drhecdc7532001-09-23 02:35:53 +00002683
drh8dcd7ca2004-08-08 19:43:29 +00002684 *ppCur = 0;
2685 if( wrFlag ){
drh8dcd7ca2004-08-08 19:43:29 +00002686 if( pBt->readOnly ){
2687 return SQLITE_READONLY;
2688 }
drh980b1a72006-08-16 16:42:48 +00002689 if( checkReadLocks(p, iTable, 0) ){
drh8dcd7ca2004-08-08 19:43:29 +00002690 return SQLITE_LOCKED;
2691 }
drha0c9a112004-03-10 13:42:37 +00002692 }
danielk1977aef0bf62005-12-30 16:28:01 +00002693
drh4b70f112004-05-02 21:12:19 +00002694 if( pBt->pPage1==0 ){
danielk1977aef0bf62005-12-30 16:28:01 +00002695 rc = lockBtreeWithRetry(p);
drha059ad02001-04-17 20:09:11 +00002696 if( rc!=SQLITE_OK ){
drha059ad02001-04-17 20:09:11 +00002697 return rc;
2698 }
2699 }
danielk1977da184232006-01-05 11:34:32 +00002700 pCur = sqliteMalloc( sizeof(*pCur) );
drha059ad02001-04-17 20:09:11 +00002701 if( pCur==0 ){
drhbd03cae2001-06-02 02:40:57 +00002702 rc = SQLITE_NOMEM;
2703 goto create_cursor_exception;
2704 }
drh8b2f49b2001-06-08 00:21:52 +00002705 pCur->pgnoRoot = (Pgno)iTable;
drh24cd67e2004-05-10 16:18:47 +00002706 if( iTable==1 && sqlite3pager_pagecount(pBt->pPager)==0 ){
2707 rc = SQLITE_EMPTY;
2708 goto create_cursor_exception;
2709 }
drhde647132004-05-07 17:57:49 +00002710 rc = getAndInitPage(pBt, pCur->pgnoRoot, &pCur->pPage, 0);
drhbd03cae2001-06-02 02:40:57 +00002711 if( rc!=SQLITE_OK ){
2712 goto create_cursor_exception;
drha059ad02001-04-17 20:09:11 +00002713 }
danielk1977aef0bf62005-12-30 16:28:01 +00002714
danielk1977aef0bf62005-12-30 16:28:01 +00002715 /* Now that no other errors can occur, finish filling in the BtCursor
2716 ** variables, link the cursor into the BtShared list and set *ppCur (the
2717 ** output argument to this function).
2718 */
drh3aac2dd2004-04-26 14:10:20 +00002719 pCur->xCompare = xCmp ? xCmp : dfltCompare;
2720 pCur->pArg = pArg;
danielk1977aef0bf62005-12-30 16:28:01 +00002721 pCur->pBtree = p;
drhecdc7532001-09-23 02:35:53 +00002722 pCur->wrFlag = wrFlag;
drha059ad02001-04-17 20:09:11 +00002723 pCur->pNext = pBt->pCursor;
2724 if( pCur->pNext ){
2725 pCur->pNext->pPrev = pCur;
2726 }
2727 pBt->pCursor = pCur;
danielk1977da184232006-01-05 11:34:32 +00002728 pCur->eState = CURSOR_INVALID;
drh2af926b2001-05-15 00:39:25 +00002729 *ppCur = pCur;
drhbd03cae2001-06-02 02:40:57 +00002730
danielk1977aef0bf62005-12-30 16:28:01 +00002731 return SQLITE_OK;
drhbd03cae2001-06-02 02:40:57 +00002732create_cursor_exception:
drhbd03cae2001-06-02 02:40:57 +00002733 if( pCur ){
drh3aac2dd2004-04-26 14:10:20 +00002734 releasePage(pCur->pPage);
drhbd03cae2001-06-02 02:40:57 +00002735 sqliteFree(pCur);
2736 }
drh5e00f6c2001-09-13 13:46:56 +00002737 unlockBtreeIfUnused(pBt);
drhbd03cae2001-06-02 02:40:57 +00002738 return rc;
drha059ad02001-04-17 20:09:11 +00002739}
2740
drh7a224de2004-06-02 01:22:02 +00002741#if 0 /* Not Used */
drhd3d39e92004-05-20 22:16:29 +00002742/*
2743** Change the value of the comparison function used by a cursor.
2744*/
danielk1977bf3b7212004-05-18 10:06:24 +00002745void sqlite3BtreeSetCompare(
drhd3d39e92004-05-20 22:16:29 +00002746 BtCursor *pCur, /* The cursor to whose comparison function is changed */
2747 int(*xCmp)(void*,int,const void*,int,const void*), /* New comparison func */
2748 void *pArg /* First argument to xCmp() */
danielk1977bf3b7212004-05-18 10:06:24 +00002749){
2750 pCur->xCompare = xCmp ? xCmp : dfltCompare;
2751 pCur->pArg = pArg;
2752}
drh7a224de2004-06-02 01:22:02 +00002753#endif
danielk1977bf3b7212004-05-18 10:06:24 +00002754
drha059ad02001-04-17 20:09:11 +00002755/*
drh5e00f6c2001-09-13 13:46:56 +00002756** Close a cursor. The read lock on the database file is released
drhbd03cae2001-06-02 02:40:57 +00002757** when the last cursor is closed.
drha059ad02001-04-17 20:09:11 +00002758*/
drh3aac2dd2004-04-26 14:10:20 +00002759int sqlite3BtreeCloseCursor(BtCursor *pCur){
danielk1977aef0bf62005-12-30 16:28:01 +00002760 BtShared *pBt = pCur->pBtree->pBt;
drh777e4c42006-01-13 04:31:58 +00002761 restoreOrClearCursorPosition(pCur, 0);
drha059ad02001-04-17 20:09:11 +00002762 if( pCur->pPrev ){
2763 pCur->pPrev->pNext = pCur->pNext;
2764 }else{
2765 pBt->pCursor = pCur->pNext;
2766 }
2767 if( pCur->pNext ){
2768 pCur->pNext->pPrev = pCur->pPrev;
2769 }
drh3aac2dd2004-04-26 14:10:20 +00002770 releasePage(pCur->pPage);
drh5e00f6c2001-09-13 13:46:56 +00002771 unlockBtreeIfUnused(pBt);
drha059ad02001-04-17 20:09:11 +00002772 sqliteFree(pCur);
drh8c42ca92001-06-22 19:15:00 +00002773 return SQLITE_OK;
drha059ad02001-04-17 20:09:11 +00002774}
2775
drh7e3b0a02001-04-28 16:52:40 +00002776/*
drh5e2f8b92001-05-28 00:41:15 +00002777** Make a temporary cursor by filling in the fields of pTempCur.
2778** The temporary cursor is not on the cursor list for the Btree.
2779*/
drh14acc042001-06-10 19:56:58 +00002780static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){
drh5e2f8b92001-05-28 00:41:15 +00002781 memcpy(pTempCur, pCur, sizeof(*pCur));
2782 pTempCur->pNext = 0;
2783 pTempCur->pPrev = 0;
drhecdc7532001-09-23 02:35:53 +00002784 if( pTempCur->pPage ){
drha34b6762004-05-07 13:30:42 +00002785 sqlite3pager_ref(pTempCur->pPage->aData);
drhecdc7532001-09-23 02:35:53 +00002786 }
drh5e2f8b92001-05-28 00:41:15 +00002787}
2788
2789/*
drhbd03cae2001-06-02 02:40:57 +00002790** Delete a temporary cursor such as was made by the CreateTemporaryCursor()
drh5e2f8b92001-05-28 00:41:15 +00002791** function above.
2792*/
drh14acc042001-06-10 19:56:58 +00002793static void releaseTempCursor(BtCursor *pCur){
drhecdc7532001-09-23 02:35:53 +00002794 if( pCur->pPage ){
drha34b6762004-05-07 13:30:42 +00002795 sqlite3pager_unref(pCur->pPage->aData);
drhecdc7532001-09-23 02:35:53 +00002796 }
drh5e2f8b92001-05-28 00:41:15 +00002797}
2798
2799/*
drh9188b382004-05-14 21:12:22 +00002800** Make sure the BtCursor.info field of the given cursor is valid.
drhab01f612004-05-22 02:55:23 +00002801** If it is not already valid, call parseCell() to fill it in.
2802**
2803** BtCursor.info is a cache of the information in the current cell.
2804** Using this cache reduces the number of calls to parseCell().
drh9188b382004-05-14 21:12:22 +00002805*/
2806static void getCellInfo(BtCursor *pCur){
drh271efa52004-05-30 19:19:05 +00002807 if( pCur->info.nSize==0 ){
drh3a41a3f2004-05-30 02:14:17 +00002808 parseCell(pCur->pPage, pCur->idx, &pCur->info);
drh9188b382004-05-14 21:12:22 +00002809 }else{
2810#ifndef NDEBUG
2811 CellInfo info;
drh51c6d962004-06-06 00:42:25 +00002812 memset(&info, 0, sizeof(info));
drh3a41a3f2004-05-30 02:14:17 +00002813 parseCell(pCur->pPage, pCur->idx, &info);
drh9188b382004-05-14 21:12:22 +00002814 assert( memcmp(&info, &pCur->info, sizeof(info))==0 );
2815#endif
2816 }
2817}
2818
2819/*
drh3aac2dd2004-04-26 14:10:20 +00002820** Set *pSize to the size of the buffer needed to hold the value of
2821** the key for the current entry. If the cursor is not pointing
2822** to a valid entry, *pSize is set to 0.
2823**
drh4b70f112004-05-02 21:12:19 +00002824** For a table with the INTKEY flag set, this routine returns the key
drh3aac2dd2004-04-26 14:10:20 +00002825** itself, not the number of bytes in the key.
drh7e3b0a02001-04-28 16:52:40 +00002826*/
drh4a1c3802004-05-12 15:15:47 +00002827int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
drh777e4c42006-01-13 04:31:58 +00002828 int rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00002829 if( rc==SQLITE_OK ){
2830 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
2831 if( pCur->eState==CURSOR_INVALID ){
2832 *pSize = 0;
2833 }else{
2834 getCellInfo(pCur);
2835 *pSize = pCur->info.nKey;
2836 }
drh72f82862001-05-24 21:06:34 +00002837 }
danielk1977da184232006-01-05 11:34:32 +00002838 return rc;
drha059ad02001-04-17 20:09:11 +00002839}
drh2af926b2001-05-15 00:39:25 +00002840
drh72f82862001-05-24 21:06:34 +00002841/*
drh0e1c19e2004-05-11 00:58:56 +00002842** Set *pSize to the number of bytes of data in the entry the
2843** cursor currently points to. Always return SQLITE_OK.
2844** Failure is not possible. If the cursor is not currently
2845** pointing to an entry (which can happen, for example, if
2846** the database is empty) then *pSize is set to 0.
2847*/
2848int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
drh777e4c42006-01-13 04:31:58 +00002849 int rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00002850 if( rc==SQLITE_OK ){
2851 assert( pCur->eState==CURSOR_INVALID || pCur->eState==CURSOR_VALID );
2852 if( pCur->eState==CURSOR_INVALID ){
2853 /* Not pointing at a valid entry - set *pSize to 0. */
2854 *pSize = 0;
2855 }else{
2856 getCellInfo(pCur);
2857 *pSize = pCur->info.nData;
2858 }
drh0e1c19e2004-05-11 00:58:56 +00002859 }
danielk1977da184232006-01-05 11:34:32 +00002860 return rc;
drh0e1c19e2004-05-11 00:58:56 +00002861}
2862
2863/*
drh72f82862001-05-24 21:06:34 +00002864** Read payload information from the entry that the pCur cursor is
2865** pointing to. Begin reading the payload at "offset" and read
2866** a total of "amt" bytes. Put the result in zBuf.
2867**
2868** This routine does not make a distinction between key and data.
drhab01f612004-05-22 02:55:23 +00002869** It just reads bytes from the payload area. Data might appear
2870** on the main page or be scattered out on multiple overflow pages.
drh72f82862001-05-24 21:06:34 +00002871*/
drh3aac2dd2004-04-26 14:10:20 +00002872static int getPayload(
2873 BtCursor *pCur, /* Cursor pointing to entry to read from */
2874 int offset, /* Begin reading this far into payload */
2875 int amt, /* Read this many bytes */
2876 unsigned char *pBuf, /* Write the bytes into this buffer */
2877 int skipKey /* offset begins at data if this is true */
2878){
2879 unsigned char *aPayload;
drh2af926b2001-05-15 00:39:25 +00002880 Pgno nextPage;
drh8c42ca92001-06-22 19:15:00 +00002881 int rc;
drh3aac2dd2004-04-26 14:10:20 +00002882 MemPage *pPage;
danielk1977aef0bf62005-12-30 16:28:01 +00002883 BtShared *pBt;
drh6f11bef2004-05-13 01:12:56 +00002884 int ovflSize;
drhfa1a98a2004-05-14 19:08:17 +00002885 u32 nKey;
drh3aac2dd2004-04-26 14:10:20 +00002886
drh72f82862001-05-24 21:06:34 +00002887 assert( pCur!=0 && pCur->pPage!=0 );
danielk1977da184232006-01-05 11:34:32 +00002888 assert( pCur->eState==CURSOR_VALID );
danielk1977aef0bf62005-12-30 16:28:01 +00002889 pBt = pCur->pBtree->pBt;
drh3aac2dd2004-04-26 14:10:20 +00002890 pPage = pCur->pPage;
2891 assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
drh9188b382004-05-14 21:12:22 +00002892 getCellInfo(pCur);
drh366fda62006-01-13 02:35:09 +00002893 aPayload = pCur->info.pCell + pCur->info.nHeader;
drh3aac2dd2004-04-26 14:10:20 +00002894 if( pPage->intKey ){
drhfa1a98a2004-05-14 19:08:17 +00002895 nKey = 0;
2896 }else{
2897 nKey = pCur->info.nKey;
drh3aac2dd2004-04-26 14:10:20 +00002898 }
2899 assert( offset>=0 );
2900 if( skipKey ){
drhfa1a98a2004-05-14 19:08:17 +00002901 offset += nKey;
drh3aac2dd2004-04-26 14:10:20 +00002902 }
drhfa1a98a2004-05-14 19:08:17 +00002903 if( offset+amt > nKey+pCur->info.nData ){
drha34b6762004-05-07 13:30:42 +00002904 return SQLITE_ERROR;
drh3aac2dd2004-04-26 14:10:20 +00002905 }
drhfa1a98a2004-05-14 19:08:17 +00002906 if( offset<pCur->info.nLocal ){
drh2af926b2001-05-15 00:39:25 +00002907 int a = amt;
drhfa1a98a2004-05-14 19:08:17 +00002908 if( a+offset>pCur->info.nLocal ){
2909 a = pCur->info.nLocal - offset;
drh2af926b2001-05-15 00:39:25 +00002910 }
drha34b6762004-05-07 13:30:42 +00002911 memcpy(pBuf, &aPayload[offset], a);
drh2af926b2001-05-15 00:39:25 +00002912 if( a==amt ){
2913 return SQLITE_OK;
2914 }
drh2aa679f2001-06-25 02:11:07 +00002915 offset = 0;
drha34b6762004-05-07 13:30:42 +00002916 pBuf += a;
drh2af926b2001-05-15 00:39:25 +00002917 amt -= a;
drhdd793422001-06-28 01:54:48 +00002918 }else{
drhfa1a98a2004-05-14 19:08:17 +00002919 offset -= pCur->info.nLocal;
drhbd03cae2001-06-02 02:40:57 +00002920 }
danielk1977cfe9a692004-06-16 12:00:29 +00002921 ovflSize = pBt->usableSize - 4;
drhbd03cae2001-06-02 02:40:57 +00002922 if( amt>0 ){
drhfa1a98a2004-05-14 19:08:17 +00002923 nextPage = get4byte(&aPayload[pCur->info.nLocal]);
danielk1977cfe9a692004-06-16 12:00:29 +00002924 while( amt>0 && nextPage ){
2925 rc = sqlite3pager_get(pBt->pPager, nextPage, (void**)&aPayload);
2926 if( rc!=0 ){
2927 return rc;
drh2af926b2001-05-15 00:39:25 +00002928 }
danielk1977cfe9a692004-06-16 12:00:29 +00002929 nextPage = get4byte(aPayload);
2930 if( offset<ovflSize ){
2931 int a = amt;
2932 if( a + offset > ovflSize ){
2933 a = ovflSize - offset;
2934 }
2935 memcpy(pBuf, &aPayload[offset+4], a);
2936 offset = 0;
2937 amt -= a;
2938 pBuf += a;
2939 }else{
2940 offset -= ovflSize;
2941 }
2942 sqlite3pager_unref(aPayload);
drh2af926b2001-05-15 00:39:25 +00002943 }
drh2af926b2001-05-15 00:39:25 +00002944 }
danielk1977cfe9a692004-06-16 12:00:29 +00002945
drha7fcb052001-12-14 15:09:55 +00002946 if( amt>0 ){
drh49285702005-09-17 15:20:26 +00002947 return SQLITE_CORRUPT_BKPT;
drha7fcb052001-12-14 15:09:55 +00002948 }
2949 return SQLITE_OK;
drh2af926b2001-05-15 00:39:25 +00002950}
2951
drh72f82862001-05-24 21:06:34 +00002952/*
drh3aac2dd2004-04-26 14:10:20 +00002953** Read part of the key associated with cursor pCur. Exactly
drha34b6762004-05-07 13:30:42 +00002954** "amt" bytes will be transfered into pBuf[]. The transfer
drh3aac2dd2004-04-26 14:10:20 +00002955** begins at "offset".
drh8c1238a2003-01-02 14:43:55 +00002956**
drh3aac2dd2004-04-26 14:10:20 +00002957** Return SQLITE_OK on success or an error code if anything goes
2958** wrong. An error is returned if "offset+amt" is larger than
2959** the available payload.
drh72f82862001-05-24 21:06:34 +00002960*/
drha34b6762004-05-07 13:30:42 +00002961int sqlite3BtreeKey(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
drh777e4c42006-01-13 04:31:58 +00002962 int rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00002963 if( rc==SQLITE_OK ){
2964 assert( pCur->eState==CURSOR_VALID );
2965 assert( pCur->pPage!=0 );
2966 if( pCur->pPage->intKey ){
2967 return SQLITE_CORRUPT_BKPT;
2968 }
2969 assert( pCur->pPage->intKey==0 );
2970 assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
2971 rc = getPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
drh6575a222005-03-10 17:06:34 +00002972 }
danielk1977da184232006-01-05 11:34:32 +00002973 return rc;
drh3aac2dd2004-04-26 14:10:20 +00002974}
2975
2976/*
drh3aac2dd2004-04-26 14:10:20 +00002977** Read part of the data associated with cursor pCur. Exactly
drha34b6762004-05-07 13:30:42 +00002978** "amt" bytes will be transfered into pBuf[]. The transfer
drh3aac2dd2004-04-26 14:10:20 +00002979** begins at "offset".
2980**
2981** Return SQLITE_OK on success or an error code if anything goes
2982** wrong. An error is returned if "offset+amt" is larger than
2983** the available payload.
drh72f82862001-05-24 21:06:34 +00002984*/
drh3aac2dd2004-04-26 14:10:20 +00002985int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
drh777e4c42006-01-13 04:31:58 +00002986 int rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00002987 if( rc==SQLITE_OK ){
2988 assert( pCur->eState==CURSOR_VALID );
2989 assert( pCur->pPage!=0 );
2990 assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
2991 rc = getPayload(pCur, offset, amt, pBuf, 1);
2992 }
2993 return rc;
drh2af926b2001-05-15 00:39:25 +00002994}
2995
drh72f82862001-05-24 21:06:34 +00002996/*
drh0e1c19e2004-05-11 00:58:56 +00002997** Return a pointer to payload information from the entry that the
2998** pCur cursor is pointing to. The pointer is to the beginning of
2999** the key if skipKey==0 and it points to the beginning of data if
drhe51c44f2004-05-30 20:46:09 +00003000** skipKey==1. The number of bytes of available key/data is written
3001** into *pAmt. If *pAmt==0, then the value returned will not be
3002** a valid pointer.
drh0e1c19e2004-05-11 00:58:56 +00003003**
3004** This routine is an optimization. It is common for the entire key
3005** and data to fit on the local page and for there to be no overflow
3006** pages. When that is so, this routine can be used to access the
3007** key and data without making a copy. If the key and/or data spills
3008** onto overflow pages, then getPayload() must be used to reassembly
3009** the key/data and copy it into a preallocated buffer.
3010**
3011** The pointer returned by this routine looks directly into the cached
3012** page of the database. The data might change or move the next time
3013** any btree routine is called.
3014*/
3015static const unsigned char *fetchPayload(
3016 BtCursor *pCur, /* Cursor pointing to entry to read from */
drhe51c44f2004-05-30 20:46:09 +00003017 int *pAmt, /* Write the number of available bytes here */
drh0e1c19e2004-05-11 00:58:56 +00003018 int skipKey /* read beginning at data if this is true */
3019){
3020 unsigned char *aPayload;
3021 MemPage *pPage;
drhfa1a98a2004-05-14 19:08:17 +00003022 u32 nKey;
3023 int nLocal;
drh0e1c19e2004-05-11 00:58:56 +00003024
3025 assert( pCur!=0 && pCur->pPage!=0 );
danielk1977da184232006-01-05 11:34:32 +00003026 assert( pCur->eState==CURSOR_VALID );
drh0e1c19e2004-05-11 00:58:56 +00003027 pPage = pCur->pPage;
drh0e1c19e2004-05-11 00:58:56 +00003028 assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
drh9188b382004-05-14 21:12:22 +00003029 getCellInfo(pCur);
drh43605152004-05-29 21:46:49 +00003030 aPayload = pCur->info.pCell;
drhfa1a98a2004-05-14 19:08:17 +00003031 aPayload += pCur->info.nHeader;
drh0e1c19e2004-05-11 00:58:56 +00003032 if( pPage->intKey ){
drhfa1a98a2004-05-14 19:08:17 +00003033 nKey = 0;
3034 }else{
3035 nKey = pCur->info.nKey;
drh0e1c19e2004-05-11 00:58:56 +00003036 }
drh0e1c19e2004-05-11 00:58:56 +00003037 if( skipKey ){
drhfa1a98a2004-05-14 19:08:17 +00003038 aPayload += nKey;
3039 nLocal = pCur->info.nLocal - nKey;
drh0e1c19e2004-05-11 00:58:56 +00003040 }else{
drhfa1a98a2004-05-14 19:08:17 +00003041 nLocal = pCur->info.nLocal;
drhe51c44f2004-05-30 20:46:09 +00003042 if( nLocal>nKey ){
3043 nLocal = nKey;
3044 }
drh0e1c19e2004-05-11 00:58:56 +00003045 }
drhe51c44f2004-05-30 20:46:09 +00003046 *pAmt = nLocal;
drh0e1c19e2004-05-11 00:58:56 +00003047 return aPayload;
3048}
3049
3050
3051/*
drhe51c44f2004-05-30 20:46:09 +00003052** For the entry that cursor pCur is point to, return as
3053** many bytes of the key or data as are available on the local
3054** b-tree page. Write the number of available bytes into *pAmt.
drh0e1c19e2004-05-11 00:58:56 +00003055**
3056** The pointer returned is ephemeral. The key/data may move
3057** or be destroyed on the next call to any Btree routine.
3058**
3059** These routines is used to get quick access to key and data
3060** in the common case where no overflow pages are used.
drh0e1c19e2004-05-11 00:58:56 +00003061*/
drhe51c44f2004-05-30 20:46:09 +00003062const void *sqlite3BtreeKeyFetch(BtCursor *pCur, int *pAmt){
danielk1977da184232006-01-05 11:34:32 +00003063 if( pCur->eState==CURSOR_VALID ){
3064 return (const void*)fetchPayload(pCur, pAmt, 0);
3065 }
3066 return 0;
drh0e1c19e2004-05-11 00:58:56 +00003067}
drhe51c44f2004-05-30 20:46:09 +00003068const void *sqlite3BtreeDataFetch(BtCursor *pCur, int *pAmt){
danielk1977da184232006-01-05 11:34:32 +00003069 if( pCur->eState==CURSOR_VALID ){
3070 return (const void*)fetchPayload(pCur, pAmt, 1);
3071 }
3072 return 0;
drh0e1c19e2004-05-11 00:58:56 +00003073}
3074
3075
3076/*
drh8178a752003-01-05 21:41:40 +00003077** Move the cursor down to a new child page. The newPgno argument is the
drhab01f612004-05-22 02:55:23 +00003078** page number of the child page to move to.
drh72f82862001-05-24 21:06:34 +00003079*/
drh3aac2dd2004-04-26 14:10:20 +00003080static int moveToChild(BtCursor *pCur, u32 newPgno){
drh72f82862001-05-24 21:06:34 +00003081 int rc;
3082 MemPage *pNewPage;
drh3aac2dd2004-04-26 14:10:20 +00003083 MemPage *pOldPage;
danielk1977aef0bf62005-12-30 16:28:01 +00003084 BtShared *pBt = pCur->pBtree->pBt;
drh72f82862001-05-24 21:06:34 +00003085
danielk1977da184232006-01-05 11:34:32 +00003086 assert( pCur->eState==CURSOR_VALID );
drhde647132004-05-07 17:57:49 +00003087 rc = getAndInitPage(pBt, newPgno, &pNewPage, pCur->pPage);
drh6019e162001-07-02 17:51:45 +00003088 if( rc ) return rc;
drh428ae8c2003-01-04 16:48:09 +00003089 pNewPage->idxParent = pCur->idx;
drh3aac2dd2004-04-26 14:10:20 +00003090 pOldPage = pCur->pPage;
3091 pOldPage->idxShift = 0;
3092 releasePage(pOldPage);
drh72f82862001-05-24 21:06:34 +00003093 pCur->pPage = pNewPage;
3094 pCur->idx = 0;
drh271efa52004-05-30 19:19:05 +00003095 pCur->info.nSize = 0;
drh4be295b2003-12-16 03:44:47 +00003096 if( pNewPage->nCell<1 ){
drh49285702005-09-17 15:20:26 +00003097 return SQLITE_CORRUPT_BKPT;
drh4be295b2003-12-16 03:44:47 +00003098 }
drh72f82862001-05-24 21:06:34 +00003099 return SQLITE_OK;
3100}
3101
3102/*
drh8856d6a2004-04-29 14:42:46 +00003103** Return true if the page is the virtual root of its table.
3104**
3105** The virtual root page is the root page for most tables. But
3106** for the table rooted on page 1, sometime the real root page
3107** is empty except for the right-pointer. In such cases the
3108** virtual root page is the page that the right-pointer of page
3109** 1 is pointing to.
3110*/
3111static int isRootPage(MemPage *pPage){
3112 MemPage *pParent = pPage->pParent;
drhda200cc2004-05-09 11:51:38 +00003113 if( pParent==0 ) return 1;
3114 if( pParent->pgno>1 ) return 0;
3115 if( get2byte(&pParent->aData[pParent->hdrOffset+3])==0 ) return 1;
drh8856d6a2004-04-29 14:42:46 +00003116 return 0;
3117}
3118
3119/*
drh5e2f8b92001-05-28 00:41:15 +00003120** Move the cursor up to the parent page.
3121**
3122** pCur->idx is set to the cell index that contains the pointer
3123** to the page we are coming from. If we are coming from the
3124** right-most child page then pCur->idx is set to one more than
drhbd03cae2001-06-02 02:40:57 +00003125** the largest cell index.
drh72f82862001-05-24 21:06:34 +00003126*/
drh8178a752003-01-05 21:41:40 +00003127static void moveToParent(BtCursor *pCur){
drh72f82862001-05-24 21:06:34 +00003128 MemPage *pParent;
drh8178a752003-01-05 21:41:40 +00003129 MemPage *pPage;
drh428ae8c2003-01-04 16:48:09 +00003130 int idxParent;
drh3aac2dd2004-04-26 14:10:20 +00003131
danielk1977da184232006-01-05 11:34:32 +00003132 assert( pCur->eState==CURSOR_VALID );
drh8178a752003-01-05 21:41:40 +00003133 pPage = pCur->pPage;
3134 assert( pPage!=0 );
drh8856d6a2004-04-29 14:42:46 +00003135 assert( !isRootPage(pPage) );
drh8178a752003-01-05 21:41:40 +00003136 pParent = pPage->pParent;
3137 assert( pParent!=0 );
3138 idxParent = pPage->idxParent;
drha34b6762004-05-07 13:30:42 +00003139 sqlite3pager_ref(pParent->aData);
drh3aac2dd2004-04-26 14:10:20 +00003140 releasePage(pPage);
drh72f82862001-05-24 21:06:34 +00003141 pCur->pPage = pParent;
drh271efa52004-05-30 19:19:05 +00003142 pCur->info.nSize = 0;
drh428ae8c2003-01-04 16:48:09 +00003143 assert( pParent->idxShift==0 );
drh43605152004-05-29 21:46:49 +00003144 pCur->idx = idxParent;
drh72f82862001-05-24 21:06:34 +00003145}
3146
3147/*
3148** Move the cursor to the root page
3149*/
drh5e2f8b92001-05-28 00:41:15 +00003150static int moveToRoot(BtCursor *pCur){
drh3aac2dd2004-04-26 14:10:20 +00003151 MemPage *pRoot;
drh777e4c42006-01-13 04:31:58 +00003152 int rc = SQLITE_OK;
danielk1977aef0bf62005-12-30 16:28:01 +00003153 BtShared *pBt = pCur->pBtree->pBt;
drhbd03cae2001-06-02 02:40:57 +00003154
drh777e4c42006-01-13 04:31:58 +00003155 restoreOrClearCursorPosition(pCur, 0);
drh777e4c42006-01-13 04:31:58 +00003156 pRoot = pCur->pPage;
danielk197797a227c2006-01-20 16:32:04 +00003157 if( pRoot && pRoot->pgno==pCur->pgnoRoot ){
drh777e4c42006-01-13 04:31:58 +00003158 assert( pRoot->isInit );
3159 }else{
3160 if(
3161 SQLITE_OK!=(rc = getAndInitPage(pBt, pCur->pgnoRoot, &pRoot, 0))
3162 ){
3163 pCur->eState = CURSOR_INVALID;
3164 return rc;
3165 }
3166 releasePage(pCur->pPage);
drh777e4c42006-01-13 04:31:58 +00003167 pCur->pPage = pRoot;
drhc39e0002004-05-07 23:50:57 +00003168 }
drh72f82862001-05-24 21:06:34 +00003169 pCur->idx = 0;
drh271efa52004-05-30 19:19:05 +00003170 pCur->info.nSize = 0;
drh8856d6a2004-04-29 14:42:46 +00003171 if( pRoot->nCell==0 && !pRoot->leaf ){
3172 Pgno subpage;
3173 assert( pRoot->pgno==1 );
drh43605152004-05-29 21:46:49 +00003174 subpage = get4byte(&pRoot->aData[pRoot->hdrOffset+8]);
drh8856d6a2004-04-29 14:42:46 +00003175 assert( subpage>0 );
danielk1977da184232006-01-05 11:34:32 +00003176 pCur->eState = CURSOR_VALID;
drh4b70f112004-05-02 21:12:19 +00003177 rc = moveToChild(pCur, subpage);
drh8856d6a2004-04-29 14:42:46 +00003178 }
danielk1977da184232006-01-05 11:34:32 +00003179 pCur->eState = ((pCur->pPage->nCell>0)?CURSOR_VALID:CURSOR_INVALID);
drh8856d6a2004-04-29 14:42:46 +00003180 return rc;
drh72f82862001-05-24 21:06:34 +00003181}
drh2af926b2001-05-15 00:39:25 +00003182
drh5e2f8b92001-05-28 00:41:15 +00003183/*
3184** Move the cursor down to the left-most leaf entry beneath the
3185** entry to which it is currently pointing.
drh777e4c42006-01-13 04:31:58 +00003186**
3187** The left-most leaf is the one with the smallest key - the first
3188** in ascending order.
drh5e2f8b92001-05-28 00:41:15 +00003189*/
3190static int moveToLeftmost(BtCursor *pCur){
3191 Pgno pgno;
3192 int rc;
drh3aac2dd2004-04-26 14:10:20 +00003193 MemPage *pPage;
drh5e2f8b92001-05-28 00:41:15 +00003194
danielk1977da184232006-01-05 11:34:32 +00003195 assert( pCur->eState==CURSOR_VALID );
drh3aac2dd2004-04-26 14:10:20 +00003196 while( !(pPage = pCur->pPage)->leaf ){
drha34b6762004-05-07 13:30:42 +00003197 assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
drh43605152004-05-29 21:46:49 +00003198 pgno = get4byte(findCell(pPage, pCur->idx));
drh8178a752003-01-05 21:41:40 +00003199 rc = moveToChild(pCur, pgno);
drh5e2f8b92001-05-28 00:41:15 +00003200 if( rc ) return rc;
3201 }
3202 return SQLITE_OK;
3203}
3204
drh2dcc9aa2002-12-04 13:40:25 +00003205/*
3206** Move the cursor down to the right-most leaf entry beneath the
3207** page to which it is currently pointing. Notice the difference
3208** between moveToLeftmost() and moveToRightmost(). moveToLeftmost()
3209** finds the left-most entry beneath the *entry* whereas moveToRightmost()
3210** finds the right-most entry beneath the *page*.
drh777e4c42006-01-13 04:31:58 +00003211**
3212** The right-most entry is the one with the largest key - the last
3213** key in ascending order.
drh2dcc9aa2002-12-04 13:40:25 +00003214*/
3215static int moveToRightmost(BtCursor *pCur){
3216 Pgno pgno;
3217 int rc;
drh3aac2dd2004-04-26 14:10:20 +00003218 MemPage *pPage;
drh2dcc9aa2002-12-04 13:40:25 +00003219
danielk1977da184232006-01-05 11:34:32 +00003220 assert( pCur->eState==CURSOR_VALID );
drh3aac2dd2004-04-26 14:10:20 +00003221 while( !(pPage = pCur->pPage)->leaf ){
drh43605152004-05-29 21:46:49 +00003222 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
drh3aac2dd2004-04-26 14:10:20 +00003223 pCur->idx = pPage->nCell;
drh8178a752003-01-05 21:41:40 +00003224 rc = moveToChild(pCur, pgno);
drh2dcc9aa2002-12-04 13:40:25 +00003225 if( rc ) return rc;
3226 }
drh3aac2dd2004-04-26 14:10:20 +00003227 pCur->idx = pPage->nCell - 1;
drh271efa52004-05-30 19:19:05 +00003228 pCur->info.nSize = 0;
drh2dcc9aa2002-12-04 13:40:25 +00003229 return SQLITE_OK;
3230}
3231
drh5e00f6c2001-09-13 13:46:56 +00003232/* Move the cursor to the first entry in the table. Return SQLITE_OK
3233** on success. Set *pRes to 0 if the cursor actually points to something
drh77c679c2002-02-19 22:43:58 +00003234** or set *pRes to 1 if the table is empty.
drh5e00f6c2001-09-13 13:46:56 +00003235*/
drh3aac2dd2004-04-26 14:10:20 +00003236int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
drh5e00f6c2001-09-13 13:46:56 +00003237 int rc;
3238 rc = moveToRoot(pCur);
3239 if( rc ) return rc;
danielk1977da184232006-01-05 11:34:32 +00003240 if( pCur->eState==CURSOR_INVALID ){
drhc39e0002004-05-07 23:50:57 +00003241 assert( pCur->pPage->nCell==0 );
drh5e00f6c2001-09-13 13:46:56 +00003242 *pRes = 1;
3243 return SQLITE_OK;
3244 }
drhc39e0002004-05-07 23:50:57 +00003245 assert( pCur->pPage->nCell>0 );
drh5e00f6c2001-09-13 13:46:56 +00003246 *pRes = 0;
3247 rc = moveToLeftmost(pCur);
3248 return rc;
3249}
drh5e2f8b92001-05-28 00:41:15 +00003250
drh9562b552002-02-19 15:00:07 +00003251/* Move the cursor to the last entry in the table. Return SQLITE_OK
3252** on success. Set *pRes to 0 if the cursor actually points to something
drh77c679c2002-02-19 22:43:58 +00003253** or set *pRes to 1 if the table is empty.
drh9562b552002-02-19 15:00:07 +00003254*/
drh3aac2dd2004-04-26 14:10:20 +00003255int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
drh9562b552002-02-19 15:00:07 +00003256 int rc;
drh9562b552002-02-19 15:00:07 +00003257 rc = moveToRoot(pCur);
3258 if( rc ) return rc;
danielk1977da184232006-01-05 11:34:32 +00003259 if( CURSOR_INVALID==pCur->eState ){
drhc39e0002004-05-07 23:50:57 +00003260 assert( pCur->pPage->nCell==0 );
drh9562b552002-02-19 15:00:07 +00003261 *pRes = 1;
3262 return SQLITE_OK;
3263 }
danielk1977da184232006-01-05 11:34:32 +00003264 assert( pCur->eState==CURSOR_VALID );
drh9562b552002-02-19 15:00:07 +00003265 *pRes = 0;
drh2dcc9aa2002-12-04 13:40:25 +00003266 rc = moveToRightmost(pCur);
drh9562b552002-02-19 15:00:07 +00003267 return rc;
3268}
3269
drh3aac2dd2004-04-26 14:10:20 +00003270/* Move the cursor so that it points to an entry near pKey/nKey.
drh72f82862001-05-24 21:06:34 +00003271** Return a success code.
3272**
drh3aac2dd2004-04-26 14:10:20 +00003273** For INTKEY tables, only the nKey parameter is used. pKey is
3274** ignored. For other tables, nKey is the number of bytes of data
drh0b2f3162005-12-21 18:36:45 +00003275** in pKey. The comparison function specified when the cursor was
drh3aac2dd2004-04-26 14:10:20 +00003276** created is used to compare keys.
3277**
drh5e2f8b92001-05-28 00:41:15 +00003278** If an exact match is not found, then the cursor is always
drhbd03cae2001-06-02 02:40:57 +00003279** left pointing at a leaf page which would hold the entry if it
drh5e2f8b92001-05-28 00:41:15 +00003280** were present. The cursor might point to an entry that comes
3281** before or after the key.
3282**
drhbd03cae2001-06-02 02:40:57 +00003283** The result of comparing the key with the entry to which the
drhab01f612004-05-22 02:55:23 +00003284** cursor is written to *pRes if pRes!=NULL. The meaning of
drhbd03cae2001-06-02 02:40:57 +00003285** this value is as follows:
3286**
3287** *pRes<0 The cursor is left pointing at an entry that
drh1a844c32002-12-04 22:29:28 +00003288** is smaller than pKey or if the table is empty
3289** and the cursor is therefore left point to nothing.
drhbd03cae2001-06-02 02:40:57 +00003290**
3291** *pRes==0 The cursor is left pointing at an entry that
3292** exactly matches pKey.
3293**
3294** *pRes>0 The cursor is left pointing at an entry that
drh7c717f72001-06-24 20:39:41 +00003295** is larger than pKey.
drha059ad02001-04-17 20:09:11 +00003296*/
drh4a1c3802004-05-12 15:15:47 +00003297int sqlite3BtreeMoveto(BtCursor *pCur, const void *pKey, i64 nKey, int *pRes){
drh72f82862001-05-24 21:06:34 +00003298 int rc;
drh777e4c42006-01-13 04:31:58 +00003299 int tryRightmost;
drh5e2f8b92001-05-28 00:41:15 +00003300 rc = moveToRoot(pCur);
drh72f82862001-05-24 21:06:34 +00003301 if( rc ) return rc;
drhc39e0002004-05-07 23:50:57 +00003302 assert( pCur->pPage );
3303 assert( pCur->pPage->isInit );
drh777e4c42006-01-13 04:31:58 +00003304 tryRightmost = pCur->pPage->intKey;
danielk1977da184232006-01-05 11:34:32 +00003305 if( pCur->eState==CURSOR_INVALID ){
drhf328bc82004-05-10 23:29:49 +00003306 *pRes = -1;
drhc39e0002004-05-07 23:50:57 +00003307 assert( pCur->pPage->nCell==0 );
3308 return SQLITE_OK;
3309 }
drh14684382006-11-30 13:05:29 +00003310 for(;;){
drh72f82862001-05-24 21:06:34 +00003311 int lwr, upr;
3312 Pgno chldPg;
3313 MemPage *pPage = pCur->pPage;
drh1a844c32002-12-04 22:29:28 +00003314 int c = -1; /* pRes return if table is empty must be -1 */
drh72f82862001-05-24 21:06:34 +00003315 lwr = 0;
3316 upr = pPage->nCell-1;
drh4eec4c12005-01-21 00:22:37 +00003317 if( !pPage->intKey && pKey==0 ){
drh49285702005-09-17 15:20:26 +00003318 return SQLITE_CORRUPT_BKPT;
drh4eec4c12005-01-21 00:22:37 +00003319 }
drh72f82862001-05-24 21:06:34 +00003320 while( lwr<=upr ){
danielk197713adf8a2004-06-03 16:08:41 +00003321 void *pCellKey;
drh4a1c3802004-05-12 15:15:47 +00003322 i64 nCellKey;
drh72f82862001-05-24 21:06:34 +00003323 pCur->idx = (lwr+upr)/2;
drh366fda62006-01-13 02:35:09 +00003324 pCur->info.nSize = 0;
drh3aac2dd2004-04-26 14:10:20 +00003325 if( pPage->intKey ){
drh777e4c42006-01-13 04:31:58 +00003326 u8 *pCell;
3327 if( tryRightmost ){
3328 pCur->idx = upr;
3329 }
3330 pCell = findCell(pPage, pCur->idx) + pPage->childPtrSize;
drhd172f862006-01-12 15:01:15 +00003331 if( pPage->hasData ){
danielk1977bab45c62006-01-16 15:14:27 +00003332 u32 dummy;
drhd172f862006-01-12 15:01:15 +00003333 pCell += getVarint32(pCell, &dummy);
3334 }
danielk1977bab45c62006-01-16 15:14:27 +00003335 getVarint(pCell, (u64 *)&nCellKey);
drh3aac2dd2004-04-26 14:10:20 +00003336 if( nCellKey<nKey ){
3337 c = -1;
3338 }else if( nCellKey>nKey ){
3339 c = +1;
drh777e4c42006-01-13 04:31:58 +00003340 tryRightmost = 0;
drh3aac2dd2004-04-26 14:10:20 +00003341 }else{
3342 c = 0;
3343 }
drh3aac2dd2004-04-26 14:10:20 +00003344 }else{
drhe51c44f2004-05-30 20:46:09 +00003345 int available;
danielk197713adf8a2004-06-03 16:08:41 +00003346 pCellKey = (void *)fetchPayload(pCur, &available, 0);
drh366fda62006-01-13 02:35:09 +00003347 nCellKey = pCur->info.nKey;
drhe51c44f2004-05-30 20:46:09 +00003348 if( available>=nCellKey ){
3349 c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey);
3350 }else{
3351 pCellKey = sqliteMallocRaw( nCellKey );
3352 if( pCellKey==0 ) return SQLITE_NOMEM;
danielk197713adf8a2004-06-03 16:08:41 +00003353 rc = sqlite3BtreeKey(pCur, 0, nCellKey, (void *)pCellKey);
drhe51c44f2004-05-30 20:46:09 +00003354 c = pCur->xCompare(pCur->pArg, nCellKey, pCellKey, nKey, pKey);
3355 sqliteFree(pCellKey);
3356 if( rc ) return rc;
3357 }
drh3aac2dd2004-04-26 14:10:20 +00003358 }
drh72f82862001-05-24 21:06:34 +00003359 if( c==0 ){
drh8b18dd42004-05-12 19:18:15 +00003360 if( pPage->leafData && !pPage->leaf ){
drhfc70e6f2004-05-12 21:11:27 +00003361 lwr = pCur->idx;
3362 upr = lwr - 1;
drh8b18dd42004-05-12 19:18:15 +00003363 break;
3364 }else{
drh8b18dd42004-05-12 19:18:15 +00003365 if( pRes ) *pRes = 0;
3366 return SQLITE_OK;
3367 }
drh72f82862001-05-24 21:06:34 +00003368 }
3369 if( c<0 ){
3370 lwr = pCur->idx+1;
3371 }else{
3372 upr = pCur->idx-1;
3373 }
3374 }
3375 assert( lwr==upr+1 );
drh7aa128d2002-06-21 13:09:16 +00003376 assert( pPage->isInit );
drh3aac2dd2004-04-26 14:10:20 +00003377 if( pPage->leaf ){
drha34b6762004-05-07 13:30:42 +00003378 chldPg = 0;
drh3aac2dd2004-04-26 14:10:20 +00003379 }else if( lwr>=pPage->nCell ){
drh43605152004-05-29 21:46:49 +00003380 chldPg = get4byte(&pPage->aData[pPage->hdrOffset+8]);
drh72f82862001-05-24 21:06:34 +00003381 }else{
drh43605152004-05-29 21:46:49 +00003382 chldPg = get4byte(findCell(pPage, lwr));
drh72f82862001-05-24 21:06:34 +00003383 }
3384 if( chldPg==0 ){
drhc39e0002004-05-07 23:50:57 +00003385 assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell );
drh72f82862001-05-24 21:06:34 +00003386 if( pRes ) *pRes = c;
3387 return SQLITE_OK;
3388 }
drh428ae8c2003-01-04 16:48:09 +00003389 pCur->idx = lwr;
drh271efa52004-05-30 19:19:05 +00003390 pCur->info.nSize = 0;
drh8178a752003-01-05 21:41:40 +00003391 rc = moveToChild(pCur, chldPg);
drhc39e0002004-05-07 23:50:57 +00003392 if( rc ){
3393 return rc;
3394 }
drh72f82862001-05-24 21:06:34 +00003395 }
drhbd03cae2001-06-02 02:40:57 +00003396 /* NOT REACHED */
drh72f82862001-05-24 21:06:34 +00003397}
3398
3399/*
drhc39e0002004-05-07 23:50:57 +00003400** Return TRUE if the cursor is not pointing at an entry of the table.
3401**
3402** TRUE will be returned after a call to sqlite3BtreeNext() moves
3403** past the last entry in the table or sqlite3BtreePrev() moves past
3404** the first entry. TRUE is also returned if the table is empty.
3405*/
3406int sqlite3BtreeEof(BtCursor *pCur){
danielk1977da184232006-01-05 11:34:32 +00003407 /* TODO: What if the cursor is in CURSOR_REQUIRESEEK but all table entries
3408 ** have been deleted? This API will need to change to return an error code
3409 ** as well as the boolean result value.
3410 */
3411 return (CURSOR_VALID!=pCur->eState);
drhc39e0002004-05-07 23:50:57 +00003412}
3413
3414/*
drhbd03cae2001-06-02 02:40:57 +00003415** Advance the cursor to the next entry in the database. If
drh8c1238a2003-01-02 14:43:55 +00003416** successful then set *pRes=0. If the cursor
drhbd03cae2001-06-02 02:40:57 +00003417** was already pointing to the last entry in the database before
drh8c1238a2003-01-02 14:43:55 +00003418** this routine was called, then set *pRes=1.
drh72f82862001-05-24 21:06:34 +00003419*/
drh3aac2dd2004-04-26 14:10:20 +00003420int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
drh72f82862001-05-24 21:06:34 +00003421 int rc;
danielk197797a227c2006-01-20 16:32:04 +00003422 MemPage *pPage;
drh8b18dd42004-05-12 19:18:15 +00003423
danielk1977da184232006-01-05 11:34:32 +00003424#ifndef SQLITE_OMIT_SHARED_CACHE
drh777e4c42006-01-13 04:31:58 +00003425 rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00003426 if( rc!=SQLITE_OK ){
3427 return rc;
3428 }
3429 if( pCur->skip>0 ){
3430 pCur->skip = 0;
3431 *pRes = 0;
3432 return SQLITE_OK;
3433 }
3434 pCur->skip = 0;
danielk197797a227c2006-01-20 16:32:04 +00003435#endif
danielk1977da184232006-01-05 11:34:32 +00003436
drh8c1238a2003-01-02 14:43:55 +00003437 assert( pRes!=0 );
danielk197797a227c2006-01-20 16:32:04 +00003438 pPage = pCur->pPage;
danielk1977da184232006-01-05 11:34:32 +00003439 if( CURSOR_INVALID==pCur->eState ){
drh8c1238a2003-01-02 14:43:55 +00003440 *pRes = 1;
drhc39e0002004-05-07 23:50:57 +00003441 return SQLITE_OK;
drhecdc7532001-09-23 02:35:53 +00003442 }
drh8178a752003-01-05 21:41:40 +00003443 assert( pPage->isInit );
drh8178a752003-01-05 21:41:40 +00003444 assert( pCur->idx<pPage->nCell );
danielk19776a43f9b2004-11-16 04:57:24 +00003445
drh72f82862001-05-24 21:06:34 +00003446 pCur->idx++;
drh271efa52004-05-30 19:19:05 +00003447 pCur->info.nSize = 0;
drh8178a752003-01-05 21:41:40 +00003448 if( pCur->idx>=pPage->nCell ){
drha34b6762004-05-07 13:30:42 +00003449 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00003450 rc = moveToChild(pCur, get4byte(&pPage->aData[pPage->hdrOffset+8]));
drh5e2f8b92001-05-28 00:41:15 +00003451 if( rc ) return rc;
3452 rc = moveToLeftmost(pCur);
drh8c1238a2003-01-02 14:43:55 +00003453 *pRes = 0;
3454 return rc;
drh72f82862001-05-24 21:06:34 +00003455 }
drh5e2f8b92001-05-28 00:41:15 +00003456 do{
drh8856d6a2004-04-29 14:42:46 +00003457 if( isRootPage(pPage) ){
drh8c1238a2003-01-02 14:43:55 +00003458 *pRes = 1;
danielk1977da184232006-01-05 11:34:32 +00003459 pCur->eState = CURSOR_INVALID;
drh5e2f8b92001-05-28 00:41:15 +00003460 return SQLITE_OK;
3461 }
drh8178a752003-01-05 21:41:40 +00003462 moveToParent(pCur);
3463 pPage = pCur->pPage;
3464 }while( pCur->idx>=pPage->nCell );
drh8c1238a2003-01-02 14:43:55 +00003465 *pRes = 0;
drh8b18dd42004-05-12 19:18:15 +00003466 if( pPage->leafData ){
3467 rc = sqlite3BtreeNext(pCur, pRes);
3468 }else{
3469 rc = SQLITE_OK;
3470 }
3471 return rc;
drh8178a752003-01-05 21:41:40 +00003472 }
3473 *pRes = 0;
drh3aac2dd2004-04-26 14:10:20 +00003474 if( pPage->leaf ){
drh8178a752003-01-05 21:41:40 +00003475 return SQLITE_OK;
drh72f82862001-05-24 21:06:34 +00003476 }
drh5e2f8b92001-05-28 00:41:15 +00003477 rc = moveToLeftmost(pCur);
drh8c1238a2003-01-02 14:43:55 +00003478 return rc;
drh72f82862001-05-24 21:06:34 +00003479}
3480
drh3b7511c2001-05-26 13:15:44 +00003481/*
drh2dcc9aa2002-12-04 13:40:25 +00003482** Step the cursor to the back to the previous entry in the database. If
drh8178a752003-01-05 21:41:40 +00003483** successful then set *pRes=0. If the cursor
drh2dcc9aa2002-12-04 13:40:25 +00003484** was already pointing to the first entry in the database before
drh8178a752003-01-05 21:41:40 +00003485** this routine was called, then set *pRes=1.
drh2dcc9aa2002-12-04 13:40:25 +00003486*/
drh3aac2dd2004-04-26 14:10:20 +00003487int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
drh2dcc9aa2002-12-04 13:40:25 +00003488 int rc;
3489 Pgno pgno;
drh8178a752003-01-05 21:41:40 +00003490 MemPage *pPage;
danielk1977da184232006-01-05 11:34:32 +00003491
3492#ifndef SQLITE_OMIT_SHARED_CACHE
drh777e4c42006-01-13 04:31:58 +00003493 rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00003494 if( rc!=SQLITE_OK ){
3495 return rc;
3496 }
3497 if( pCur->skip<0 ){
3498 pCur->skip = 0;
3499 *pRes = 0;
3500 return SQLITE_OK;
3501 }
3502 pCur->skip = 0;
3503#endif
3504
3505 if( CURSOR_INVALID==pCur->eState ){
drhc39e0002004-05-07 23:50:57 +00003506 *pRes = 1;
3507 return SQLITE_OK;
3508 }
danielk19776a43f9b2004-11-16 04:57:24 +00003509
drh8178a752003-01-05 21:41:40 +00003510 pPage = pCur->pPage;
drh8178a752003-01-05 21:41:40 +00003511 assert( pPage->isInit );
drh2dcc9aa2002-12-04 13:40:25 +00003512 assert( pCur->idx>=0 );
drha34b6762004-05-07 13:30:42 +00003513 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00003514 pgno = get4byte( findCell(pPage, pCur->idx) );
drh8178a752003-01-05 21:41:40 +00003515 rc = moveToChild(pCur, pgno);
drh2dcc9aa2002-12-04 13:40:25 +00003516 if( rc ) return rc;
3517 rc = moveToRightmost(pCur);
3518 }else{
3519 while( pCur->idx==0 ){
drh8856d6a2004-04-29 14:42:46 +00003520 if( isRootPage(pPage) ){
danielk1977da184232006-01-05 11:34:32 +00003521 pCur->eState = CURSOR_INVALID;
drhc39e0002004-05-07 23:50:57 +00003522 *pRes = 1;
drh2dcc9aa2002-12-04 13:40:25 +00003523 return SQLITE_OK;
3524 }
drh8178a752003-01-05 21:41:40 +00003525 moveToParent(pCur);
3526 pPage = pCur->pPage;
drh2dcc9aa2002-12-04 13:40:25 +00003527 }
3528 pCur->idx--;
drh271efa52004-05-30 19:19:05 +00003529 pCur->info.nSize = 0;
drh8237d452004-11-22 19:07:09 +00003530 if( pPage->leafData && !pPage->leaf ){
drh8b18dd42004-05-12 19:18:15 +00003531 rc = sqlite3BtreePrevious(pCur, pRes);
3532 }else{
3533 rc = SQLITE_OK;
3534 }
drh2dcc9aa2002-12-04 13:40:25 +00003535 }
drh8178a752003-01-05 21:41:40 +00003536 *pRes = 0;
drh2dcc9aa2002-12-04 13:40:25 +00003537 return rc;
3538}
3539
3540/*
drh3b7511c2001-05-26 13:15:44 +00003541** Allocate a new page from the database file.
3542**
drha34b6762004-05-07 13:30:42 +00003543** The new page is marked as dirty. (In other words, sqlite3pager_write()
drh3b7511c2001-05-26 13:15:44 +00003544** has already been called on the new page.) The new page has also
3545** been referenced and the calling routine is responsible for calling
drha34b6762004-05-07 13:30:42 +00003546** sqlite3pager_unref() on the new page when it is done.
drh3b7511c2001-05-26 13:15:44 +00003547**
3548** SQLITE_OK is returned on success. Any other return value indicates
3549** an error. *ppPage and *pPgno are undefined in the event of an error.
drha34b6762004-05-07 13:30:42 +00003550** Do not invoke sqlite3pager_unref() on *ppPage if an error is returned.
drhbea00b92002-07-08 10:59:50 +00003551**
drh199e3cf2002-07-18 11:01:47 +00003552** If the "nearby" parameter is not 0, then a (feeble) effort is made to
3553** locate a page close to the page number "nearby". This can be used in an
drhbea00b92002-07-08 10:59:50 +00003554** attempt to keep related pages close to each other in the database file,
3555** which in turn can make database access faster.
danielk1977cb1a7eb2004-11-05 12:27:02 +00003556**
3557** If the "exact" parameter is not 0, and the page-number nearby exists
3558** anywhere on the free-list, then it is guarenteed to be returned. This
3559** is only used by auto-vacuum databases when allocating a new table.
drh3b7511c2001-05-26 13:15:44 +00003560*/
danielk1977cb1a7eb2004-11-05 12:27:02 +00003561static int allocatePage(
danielk1977aef0bf62005-12-30 16:28:01 +00003562 BtShared *pBt,
danielk1977cb1a7eb2004-11-05 12:27:02 +00003563 MemPage **ppPage,
3564 Pgno *pPgno,
3565 Pgno nearby,
3566 u8 exact
3567){
drh3aac2dd2004-04-26 14:10:20 +00003568 MemPage *pPage1;
drh8c42ca92001-06-22 19:15:00 +00003569 int rc;
drh3aac2dd2004-04-26 14:10:20 +00003570 int n; /* Number of pages on the freelist */
3571 int k; /* Number of leaves on the trunk of the freelist */
drh30e58752002-03-02 20:41:57 +00003572
drh3aac2dd2004-04-26 14:10:20 +00003573 pPage1 = pBt->pPage1;
3574 n = get4byte(&pPage1->aData[36]);
3575 if( n>0 ){
drh91025292004-05-03 19:49:32 +00003576 /* There are pages on the freelist. Reuse one of those pages. */
danielk1977cb1a7eb2004-11-05 12:27:02 +00003577 MemPage *pTrunk = 0;
3578 Pgno iTrunk;
3579 MemPage *pPrevTrunk = 0;
3580 u8 searchList = 0; /* If the free-list must be searched for 'nearby' */
3581
3582 /* If the 'exact' parameter was true and a query of the pointer-map
3583 ** shows that the page 'nearby' is somewhere on the free-list, then
3584 ** the entire-list will be searched for that page.
3585 */
3586#ifndef SQLITE_OMIT_AUTOVACUUM
3587 if( exact ){
3588 u8 eType;
3589 assert( nearby>0 );
3590 assert( pBt->autoVacuum );
3591 rc = ptrmapGet(pBt, nearby, &eType, 0);
3592 if( rc ) return rc;
3593 if( eType==PTRMAP_FREEPAGE ){
3594 searchList = 1;
3595 }
3596 *pPgno = nearby;
3597 }
3598#endif
3599
3600 /* Decrement the free-list count by 1. Set iTrunk to the index of the
3601 ** first free-list trunk page. iPrevTrunk is initially 1.
3602 */
drha34b6762004-05-07 13:30:42 +00003603 rc = sqlite3pager_write(pPage1->aData);
drh3b7511c2001-05-26 13:15:44 +00003604 if( rc ) return rc;
drh3aac2dd2004-04-26 14:10:20 +00003605 put4byte(&pPage1->aData[36], n-1);
danielk1977cb1a7eb2004-11-05 12:27:02 +00003606
3607 /* The code within this loop is run only once if the 'searchList' variable
3608 ** is not true. Otherwise, it runs once for each trunk-page on the
3609 ** free-list until the page 'nearby' is located.
3610 */
3611 do {
3612 pPrevTrunk = pTrunk;
3613 if( pPrevTrunk ){
3614 iTrunk = get4byte(&pPrevTrunk->aData[0]);
drhbea00b92002-07-08 10:59:50 +00003615 }else{
danielk1977cb1a7eb2004-11-05 12:27:02 +00003616 iTrunk = get4byte(&pPage1->aData[32]);
drhbea00b92002-07-08 10:59:50 +00003617 }
danielk1977cb1a7eb2004-11-05 12:27:02 +00003618 rc = getPage(pBt, iTrunk, &pTrunk);
3619 if( rc ){
3620 releasePage(pPrevTrunk);
3621 return rc;
3622 }
3623
3624 /* TODO: This should move to after the loop? */
3625 rc = sqlite3pager_write(pTrunk->aData);
3626 if( rc ){
3627 releasePage(pTrunk);
3628 releasePage(pPrevTrunk);
3629 return rc;
3630 }
3631
3632 k = get4byte(&pTrunk->aData[4]);
3633 if( k==0 && !searchList ){
3634 /* The trunk has no leaves and the list is not being searched.
3635 ** So extract the trunk page itself and use it as the newly
3636 ** allocated page */
3637 assert( pPrevTrunk==0 );
3638 *pPgno = iTrunk;
3639 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
3640 *ppPage = pTrunk;
3641 pTrunk = 0;
3642 TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
3643 }else if( k>pBt->usableSize/4 - 8 ){
3644 /* Value of k is out of range. Database corruption */
drh49285702005-09-17 15:20:26 +00003645 return SQLITE_CORRUPT_BKPT;
danielk1977cb1a7eb2004-11-05 12:27:02 +00003646#ifndef SQLITE_OMIT_AUTOVACUUM
3647 }else if( searchList && nearby==iTrunk ){
3648 /* The list is being searched and this trunk page is the page
3649 ** to allocate, regardless of whether it has leaves.
3650 */
3651 assert( *pPgno==iTrunk );
3652 *ppPage = pTrunk;
3653 searchList = 0;
3654 if( k==0 ){
3655 if( !pPrevTrunk ){
3656 memcpy(&pPage1->aData[32], &pTrunk->aData[0], 4);
3657 }else{
3658 memcpy(&pPrevTrunk->aData[0], &pTrunk->aData[0], 4);
3659 }
3660 }else{
3661 /* The trunk page is required by the caller but it contains
3662 ** pointers to free-list leaves. The first leaf becomes a trunk
3663 ** page in this case.
3664 */
3665 MemPage *pNewTrunk;
3666 Pgno iNewTrunk = get4byte(&pTrunk->aData[8]);
3667 rc = getPage(pBt, iNewTrunk, &pNewTrunk);
3668 if( rc!=SQLITE_OK ){
3669 releasePage(pTrunk);
3670 releasePage(pPrevTrunk);
3671 return rc;
3672 }
3673 rc = sqlite3pager_write(pNewTrunk->aData);
3674 if( rc!=SQLITE_OK ){
3675 releasePage(pNewTrunk);
3676 releasePage(pTrunk);
3677 releasePage(pPrevTrunk);
3678 return rc;
3679 }
3680 memcpy(&pNewTrunk->aData[0], &pTrunk->aData[0], 4);
3681 put4byte(&pNewTrunk->aData[4], k-1);
3682 memcpy(&pNewTrunk->aData[8], &pTrunk->aData[12], (k-1)*4);
3683 if( !pPrevTrunk ){
3684 put4byte(&pPage1->aData[32], iNewTrunk);
3685 }else{
3686 put4byte(&pPrevTrunk->aData[0], iNewTrunk);
3687 }
3688 releasePage(pNewTrunk);
3689 }
3690 pTrunk = 0;
3691 TRACE(("ALLOCATE: %d trunk - %d free pages left\n", *pPgno, n-1));
3692#endif
3693 }else{
3694 /* Extract a leaf from the trunk */
3695 int closest;
3696 Pgno iPage;
3697 unsigned char *aData = pTrunk->aData;
3698 if( nearby>0 ){
3699 int i, dist;
3700 closest = 0;
3701 dist = get4byte(&aData[8]) - nearby;
3702 if( dist<0 ) dist = -dist;
3703 for(i=1; i<k; i++){
3704 int d2 = get4byte(&aData[8+i*4]) - nearby;
3705 if( d2<0 ) d2 = -d2;
3706 if( d2<dist ){
3707 closest = i;
3708 dist = d2;
3709 }
3710 }
3711 }else{
3712 closest = 0;
3713 }
3714
3715 iPage = get4byte(&aData[8+closest*4]);
3716 if( !searchList || iPage==nearby ){
3717 *pPgno = iPage;
3718 if( *pPgno>sqlite3pager_pagecount(pBt->pPager) ){
3719 /* Free page off the end of the file */
drh49285702005-09-17 15:20:26 +00003720 return SQLITE_CORRUPT_BKPT;
danielk1977cb1a7eb2004-11-05 12:27:02 +00003721 }
3722 TRACE(("ALLOCATE: %d was leaf %d of %d on trunk %d"
3723 ": %d more free pages\n",
3724 *pPgno, closest+1, k, pTrunk->pgno, n-1));
3725 if( closest<k-1 ){
3726 memcpy(&aData[8+closest*4], &aData[4+k*4], 4);
3727 }
3728 put4byte(&aData[4], k-1);
3729 rc = getPage(pBt, *pPgno, ppPage);
3730 if( rc==SQLITE_OK ){
3731 sqlite3pager_dont_rollback((*ppPage)->aData);
3732 rc = sqlite3pager_write((*ppPage)->aData);
danielk1977aac0a382005-01-16 11:07:06 +00003733 if( rc!=SQLITE_OK ){
3734 releasePage(*ppPage);
3735 }
danielk1977cb1a7eb2004-11-05 12:27:02 +00003736 }
3737 searchList = 0;
3738 }
drhee696e22004-08-30 16:52:17 +00003739 }
danielk1977cb1a7eb2004-11-05 12:27:02 +00003740 releasePage(pPrevTrunk);
3741 }while( searchList );
3742 releasePage(pTrunk);
drh3b7511c2001-05-26 13:15:44 +00003743 }else{
drh3aac2dd2004-04-26 14:10:20 +00003744 /* There are no pages on the freelist, so create a new page at the
3745 ** end of the file */
drha34b6762004-05-07 13:30:42 +00003746 *pPgno = sqlite3pager_pagecount(pBt->pPager) + 1;
danielk1977afcdd022004-10-31 16:25:42 +00003747
3748#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977266664d2006-02-10 08:24:21 +00003749 if( pBt->autoVacuum && PTRMAP_ISPAGE(pBt, *pPgno) ){
danielk1977afcdd022004-10-31 16:25:42 +00003750 /* If *pPgno refers to a pointer-map page, allocate two new pages
3751 ** at the end of the file instead of one. The first allocated page
3752 ** becomes a new pointer-map page, the second is used by the caller.
3753 */
3754 TRACE(("ALLOCATE: %d from end of file (pointer-map page)\n", *pPgno));
danielk1977599fcba2004-11-08 07:13:13 +00003755 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
danielk1977afcdd022004-10-31 16:25:42 +00003756 (*pPgno)++;
3757 }
3758#endif
3759
danielk1977599fcba2004-11-08 07:13:13 +00003760 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
drh3aac2dd2004-04-26 14:10:20 +00003761 rc = getPage(pBt, *pPgno, ppPage);
drh3b7511c2001-05-26 13:15:44 +00003762 if( rc ) return rc;
drha34b6762004-05-07 13:30:42 +00003763 rc = sqlite3pager_write((*ppPage)->aData);
danielk1977aac0a382005-01-16 11:07:06 +00003764 if( rc!=SQLITE_OK ){
3765 releasePage(*ppPage);
3766 }
drh3a4c1412004-05-09 20:40:11 +00003767 TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
drh3b7511c2001-05-26 13:15:44 +00003768 }
danielk1977599fcba2004-11-08 07:13:13 +00003769
3770 assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );
drh3b7511c2001-05-26 13:15:44 +00003771 return rc;
3772}
3773
3774/*
drh3aac2dd2004-04-26 14:10:20 +00003775** Add a page of the database file to the freelist.
drh5e2f8b92001-05-28 00:41:15 +00003776**
drha34b6762004-05-07 13:30:42 +00003777** sqlite3pager_unref() is NOT called for pPage.
drh3b7511c2001-05-26 13:15:44 +00003778*/
drh3aac2dd2004-04-26 14:10:20 +00003779static int freePage(MemPage *pPage){
danielk1977aef0bf62005-12-30 16:28:01 +00003780 BtShared *pBt = pPage->pBt;
drh3aac2dd2004-04-26 14:10:20 +00003781 MemPage *pPage1 = pBt->pPage1;
3782 int rc, n, k;
drh8b2f49b2001-06-08 00:21:52 +00003783
drh3aac2dd2004-04-26 14:10:20 +00003784 /* Prepare the page for freeing */
3785 assert( pPage->pgno>1 );
3786 pPage->isInit = 0;
3787 releasePage(pPage->pParent);
3788 pPage->pParent = 0;
3789
drha34b6762004-05-07 13:30:42 +00003790 /* Increment the free page count on pPage1 */
3791 rc = sqlite3pager_write(pPage1->aData);
drh3aac2dd2004-04-26 14:10:20 +00003792 if( rc ) return rc;
3793 n = get4byte(&pPage1->aData[36]);
3794 put4byte(&pPage1->aData[36], n+1);
3795
drhfcce93f2006-02-22 03:08:32 +00003796#ifdef SQLITE_SECURE_DELETE
3797 /* If the SQLITE_SECURE_DELETE compile-time option is enabled, then
3798 ** always fully overwrite deleted information with zeros.
3799 */
3800 rc = sqlite3pager_write(pPage->aData);
3801 if( rc ) return rc;
3802 memset(pPage->aData, 0, pPage->pBt->pageSize);
3803#endif
3804
danielk1977687566d2004-11-02 12:56:41 +00003805#ifndef SQLITE_OMIT_AUTOVACUUM
3806 /* If the database supports auto-vacuum, write an entry in the pointer-map
danielk1977cb1a7eb2004-11-05 12:27:02 +00003807 ** to indicate that the page is free.
danielk1977687566d2004-11-02 12:56:41 +00003808 */
3809 if( pBt->autoVacuum ){
3810 rc = ptrmapPut(pBt, pPage->pgno, PTRMAP_FREEPAGE, 0);
danielk1977a64a0352004-11-05 01:45:13 +00003811 if( rc ) return rc;
danielk1977687566d2004-11-02 12:56:41 +00003812 }
3813#endif
3814
drh3aac2dd2004-04-26 14:10:20 +00003815 if( n==0 ){
3816 /* This is the first free page */
drhda200cc2004-05-09 11:51:38 +00003817 rc = sqlite3pager_write(pPage->aData);
3818 if( rc ) return rc;
drh3aac2dd2004-04-26 14:10:20 +00003819 memset(pPage->aData, 0, 8);
drha34b6762004-05-07 13:30:42 +00003820 put4byte(&pPage1->aData[32], pPage->pgno);
drh3a4c1412004-05-09 20:40:11 +00003821 TRACE(("FREE-PAGE: %d first\n", pPage->pgno));
drh3aac2dd2004-04-26 14:10:20 +00003822 }else{
3823 /* Other free pages already exist. Retrive the first trunk page
3824 ** of the freelist and find out how many leaves it has. */
drha34b6762004-05-07 13:30:42 +00003825 MemPage *pTrunk;
3826 rc = getPage(pBt, get4byte(&pPage1->aData[32]), &pTrunk);
drh3b7511c2001-05-26 13:15:44 +00003827 if( rc ) return rc;
drh3aac2dd2004-04-26 14:10:20 +00003828 k = get4byte(&pTrunk->aData[4]);
drhee696e22004-08-30 16:52:17 +00003829 if( k>=pBt->usableSize/4 - 8 ){
drh3aac2dd2004-04-26 14:10:20 +00003830 /* The trunk is full. Turn the page being freed into a new
3831 ** trunk page with no leaves. */
drha34b6762004-05-07 13:30:42 +00003832 rc = sqlite3pager_write(pPage->aData);
drh3aac2dd2004-04-26 14:10:20 +00003833 if( rc ) return rc;
3834 put4byte(pPage->aData, pTrunk->pgno);
3835 put4byte(&pPage->aData[4], 0);
3836 put4byte(&pPage1->aData[32], pPage->pgno);
drh3a4c1412004-05-09 20:40:11 +00003837 TRACE(("FREE-PAGE: %d new trunk page replacing %d\n",
3838 pPage->pgno, pTrunk->pgno));
drh3aac2dd2004-04-26 14:10:20 +00003839 }else{
3840 /* Add the newly freed page as a leaf on the current trunk */
drha34b6762004-05-07 13:30:42 +00003841 rc = sqlite3pager_write(pTrunk->aData);
drh3aac2dd2004-04-26 14:10:20 +00003842 if( rc ) return rc;
3843 put4byte(&pTrunk->aData[4], k+1);
3844 put4byte(&pTrunk->aData[8+k*4], pPage->pgno);
drhfcce93f2006-02-22 03:08:32 +00003845#ifndef SQLITE_SECURE_DELETE
drha34b6762004-05-07 13:30:42 +00003846 sqlite3pager_dont_write(pBt->pPager, pPage->pgno);
drhfcce93f2006-02-22 03:08:32 +00003847#endif
drh3a4c1412004-05-09 20:40:11 +00003848 TRACE(("FREE-PAGE: %d leaf on trunk page %d\n",pPage->pgno,pTrunk->pgno));
drh3aac2dd2004-04-26 14:10:20 +00003849 }
3850 releasePage(pTrunk);
drh3b7511c2001-05-26 13:15:44 +00003851 }
drh3b7511c2001-05-26 13:15:44 +00003852 return rc;
3853}
3854
3855/*
drh3aac2dd2004-04-26 14:10:20 +00003856** Free any overflow pages associated with the given Cell.
drh3b7511c2001-05-26 13:15:44 +00003857*/
drh3aac2dd2004-04-26 14:10:20 +00003858static int clearCell(MemPage *pPage, unsigned char *pCell){
danielk1977aef0bf62005-12-30 16:28:01 +00003859 BtShared *pBt = pPage->pBt;
drh6f11bef2004-05-13 01:12:56 +00003860 CellInfo info;
drh3aac2dd2004-04-26 14:10:20 +00003861 Pgno ovflPgno;
drh6f11bef2004-05-13 01:12:56 +00003862 int rc;
drh3b7511c2001-05-26 13:15:44 +00003863
drh43605152004-05-29 21:46:49 +00003864 parseCellPtr(pPage, pCell, &info);
drh6f11bef2004-05-13 01:12:56 +00003865 if( info.iOverflow==0 ){
drha34b6762004-05-07 13:30:42 +00003866 return SQLITE_OK; /* No overflow pages. Return without doing anything */
drh3aac2dd2004-04-26 14:10:20 +00003867 }
drh6f11bef2004-05-13 01:12:56 +00003868 ovflPgno = get4byte(&pCell[info.iOverflow]);
drh3aac2dd2004-04-26 14:10:20 +00003869 while( ovflPgno!=0 ){
3870 MemPage *pOvfl;
danielk1977a1cb1832005-02-12 08:59:55 +00003871 if( ovflPgno>sqlite3pager_pagecount(pBt->pPager) ){
drh49285702005-09-17 15:20:26 +00003872 return SQLITE_CORRUPT_BKPT;
danielk1977a1cb1832005-02-12 08:59:55 +00003873 }
drh3aac2dd2004-04-26 14:10:20 +00003874 rc = getPage(pBt, ovflPgno, &pOvfl);
drh3b7511c2001-05-26 13:15:44 +00003875 if( rc ) return rc;
drh3aac2dd2004-04-26 14:10:20 +00003876 ovflPgno = get4byte(pOvfl->aData);
drha34b6762004-05-07 13:30:42 +00003877 rc = freePage(pOvfl);
drha34b6762004-05-07 13:30:42 +00003878 sqlite3pager_unref(pOvfl->aData);
danielk19776b456a22005-03-21 04:04:02 +00003879 if( rc ) return rc;
drh3b7511c2001-05-26 13:15:44 +00003880 }
drh5e2f8b92001-05-28 00:41:15 +00003881 return SQLITE_OK;
drh3b7511c2001-05-26 13:15:44 +00003882}
3883
3884/*
drh91025292004-05-03 19:49:32 +00003885** Create the byte sequence used to represent a cell on page pPage
3886** and write that byte sequence into pCell[]. Overflow pages are
3887** allocated and filled in as necessary. The calling procedure
3888** is responsible for making sure sufficient space has been allocated
3889** for pCell[].
3890**
3891** Note that pCell does not necessary need to point to the pPage->aData
3892** area. pCell might point to some temporary storage. The cell will
3893** be constructed in this temporary area then copied into pPage->aData
3894** later.
drh3b7511c2001-05-26 13:15:44 +00003895*/
3896static int fillInCell(
drh3aac2dd2004-04-26 14:10:20 +00003897 MemPage *pPage, /* The page that contains the cell */
drh4b70f112004-05-02 21:12:19 +00003898 unsigned char *pCell, /* Complete text of the cell */
drh4a1c3802004-05-12 15:15:47 +00003899 const void *pKey, i64 nKey, /* The key */
drh4b70f112004-05-02 21:12:19 +00003900 const void *pData,int nData, /* The data */
3901 int *pnSize /* Write cell size here */
drh3b7511c2001-05-26 13:15:44 +00003902){
drh3b7511c2001-05-26 13:15:44 +00003903 int nPayload;
drh8c6fa9b2004-05-26 00:01:53 +00003904 const u8 *pSrc;
drha34b6762004-05-07 13:30:42 +00003905 int nSrc, n, rc;
drh3aac2dd2004-04-26 14:10:20 +00003906 int spaceLeft;
3907 MemPage *pOvfl = 0;
drh9b171272004-05-08 02:03:22 +00003908 MemPage *pToRelease = 0;
drh3aac2dd2004-04-26 14:10:20 +00003909 unsigned char *pPrior;
3910 unsigned char *pPayload;
danielk1977aef0bf62005-12-30 16:28:01 +00003911 BtShared *pBt = pPage->pBt;
drh3aac2dd2004-04-26 14:10:20 +00003912 Pgno pgnoOvfl = 0;
drh4b70f112004-05-02 21:12:19 +00003913 int nHeader;
drh6f11bef2004-05-13 01:12:56 +00003914 CellInfo info;
drh3b7511c2001-05-26 13:15:44 +00003915
drh91025292004-05-03 19:49:32 +00003916 /* Fill in the header. */
drh43605152004-05-29 21:46:49 +00003917 nHeader = 0;
drh91025292004-05-03 19:49:32 +00003918 if( !pPage->leaf ){
3919 nHeader += 4;
3920 }
drh8b18dd42004-05-12 19:18:15 +00003921 if( pPage->hasData ){
drh91025292004-05-03 19:49:32 +00003922 nHeader += putVarint(&pCell[nHeader], nData);
drh6f11bef2004-05-13 01:12:56 +00003923 }else{
drh91025292004-05-03 19:49:32 +00003924 nData = 0;
3925 }
drh6f11bef2004-05-13 01:12:56 +00003926 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
drh43605152004-05-29 21:46:49 +00003927 parseCellPtr(pPage, pCell, &info);
drh6f11bef2004-05-13 01:12:56 +00003928 assert( info.nHeader==nHeader );
3929 assert( info.nKey==nKey );
3930 assert( info.nData==nData );
3931
3932 /* Fill in the payload */
drh3aac2dd2004-04-26 14:10:20 +00003933 nPayload = nData;
3934 if( pPage->intKey ){
3935 pSrc = pData;
3936 nSrc = nData;
drh91025292004-05-03 19:49:32 +00003937 nData = 0;
drh3aac2dd2004-04-26 14:10:20 +00003938 }else{
3939 nPayload += nKey;
3940 pSrc = pKey;
3941 nSrc = nKey;
3942 }
drh6f11bef2004-05-13 01:12:56 +00003943 *pnSize = info.nSize;
3944 spaceLeft = info.nLocal;
drh3aac2dd2004-04-26 14:10:20 +00003945 pPayload = &pCell[nHeader];
drh6f11bef2004-05-13 01:12:56 +00003946 pPrior = &pCell[info.iOverflow];
drh3b7511c2001-05-26 13:15:44 +00003947
drh3b7511c2001-05-26 13:15:44 +00003948 while( nPayload>0 ){
3949 if( spaceLeft==0 ){
danielk1977afcdd022004-10-31 16:25:42 +00003950#ifndef SQLITE_OMIT_AUTOVACUUM
3951 Pgno pgnoPtrmap = pgnoOvfl; /* Overflow page pointer-map entry page */
3952#endif
danielk1977cb1a7eb2004-11-05 12:27:02 +00003953 rc = allocatePage(pBt, &pOvfl, &pgnoOvfl, pgnoOvfl, 0);
danielk1977afcdd022004-10-31 16:25:42 +00003954#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977a19df672004-11-03 11:37:07 +00003955 /* If the database supports auto-vacuum, and the second or subsequent
3956 ** overflow page is being allocated, add an entry to the pointer-map
3957 ** for that page now. The entry for the first overflow page will be
3958 ** added later, by the insertCell() routine.
danielk1977afcdd022004-10-31 16:25:42 +00003959 */
danielk1977a19df672004-11-03 11:37:07 +00003960 if( pBt->autoVacuum && pgnoPtrmap!=0 && rc==SQLITE_OK ){
3961 rc = ptrmapPut(pBt, pgnoOvfl, PTRMAP_OVERFLOW2, pgnoPtrmap);
danielk1977afcdd022004-10-31 16:25:42 +00003962 }
3963#endif
drh3b7511c2001-05-26 13:15:44 +00003964 if( rc ){
drh9b171272004-05-08 02:03:22 +00003965 releasePage(pToRelease);
danielk197728129562005-01-11 10:25:06 +00003966 /* clearCell(pPage, pCell); */
drh3b7511c2001-05-26 13:15:44 +00003967 return rc;
3968 }
drh3aac2dd2004-04-26 14:10:20 +00003969 put4byte(pPrior, pgnoOvfl);
drh9b171272004-05-08 02:03:22 +00003970 releasePage(pToRelease);
3971 pToRelease = pOvfl;
drh3aac2dd2004-04-26 14:10:20 +00003972 pPrior = pOvfl->aData;
3973 put4byte(pPrior, 0);
3974 pPayload = &pOvfl->aData[4];
drhb6f41482004-05-14 01:58:11 +00003975 spaceLeft = pBt->usableSize - 4;
drh3b7511c2001-05-26 13:15:44 +00003976 }
3977 n = nPayload;
3978 if( n>spaceLeft ) n = spaceLeft;
drh3aac2dd2004-04-26 14:10:20 +00003979 if( n>nSrc ) n = nSrc;
drhff3b1702006-03-11 12:04:18 +00003980 assert( pSrc );
drh3aac2dd2004-04-26 14:10:20 +00003981 memcpy(pPayload, pSrc, n);
drh3b7511c2001-05-26 13:15:44 +00003982 nPayload -= n;
drhde647132004-05-07 17:57:49 +00003983 pPayload += n;
drh9b171272004-05-08 02:03:22 +00003984 pSrc += n;
drh3aac2dd2004-04-26 14:10:20 +00003985 nSrc -= n;
drh3b7511c2001-05-26 13:15:44 +00003986 spaceLeft -= n;
drh3aac2dd2004-04-26 14:10:20 +00003987 if( nSrc==0 ){
3988 nSrc = nData;
3989 pSrc = pData;
3990 }
drhdd793422001-06-28 01:54:48 +00003991 }
drh9b171272004-05-08 02:03:22 +00003992 releasePage(pToRelease);
drh3b7511c2001-05-26 13:15:44 +00003993 return SQLITE_OK;
3994}
3995
3996/*
drhbd03cae2001-06-02 02:40:57 +00003997** Change the MemPage.pParent pointer on the page whose number is
drh8b2f49b2001-06-08 00:21:52 +00003998** given in the second argument so that MemPage.pParent holds the
drhbd03cae2001-06-02 02:40:57 +00003999** pointer in the third argument.
4000*/
danielk1977aef0bf62005-12-30 16:28:01 +00004001static int reparentPage(BtShared *pBt, Pgno pgno, MemPage *pNewParent, int idx){
drhbd03cae2001-06-02 02:40:57 +00004002 MemPage *pThis;
drh4b70f112004-05-02 21:12:19 +00004003 unsigned char *aData;
drhbd03cae2001-06-02 02:40:57 +00004004
drh43617e92006-03-06 20:55:46 +00004005 assert( pNewParent!=0 );
danielk1977afcdd022004-10-31 16:25:42 +00004006 if( pgno==0 ) return SQLITE_OK;
drh4b70f112004-05-02 21:12:19 +00004007 assert( pBt->pPager!=0 );
drha34b6762004-05-07 13:30:42 +00004008 aData = sqlite3pager_lookup(pBt->pPager, pgno);
drhda200cc2004-05-09 11:51:38 +00004009 if( aData ){
drh07d183d2005-05-01 22:52:42 +00004010 pThis = (MemPage*)&aData[pBt->pageSize];
drh31276532004-09-27 12:20:52 +00004011 assert( pThis->aData==aData );
drhda200cc2004-05-09 11:51:38 +00004012 if( pThis->isInit ){
4013 if( pThis->pParent!=pNewParent ){
4014 if( pThis->pParent ) sqlite3pager_unref(pThis->pParent->aData);
4015 pThis->pParent = pNewParent;
drh43617e92006-03-06 20:55:46 +00004016 sqlite3pager_ref(pNewParent->aData);
drhda200cc2004-05-09 11:51:38 +00004017 }
4018 pThis->idxParent = idx;
drhdd793422001-06-28 01:54:48 +00004019 }
drha34b6762004-05-07 13:30:42 +00004020 sqlite3pager_unref(aData);
drhbd03cae2001-06-02 02:40:57 +00004021 }
danielk1977afcdd022004-10-31 16:25:42 +00004022
4023#ifndef SQLITE_OMIT_AUTOVACUUM
4024 if( pBt->autoVacuum ){
4025 return ptrmapPut(pBt, pgno, PTRMAP_BTREE, pNewParent->pgno);
4026 }
4027#endif
4028 return SQLITE_OK;
drhbd03cae2001-06-02 02:40:57 +00004029}
4030
danielk1977ac11ee62005-01-15 12:45:51 +00004031
4032
drhbd03cae2001-06-02 02:40:57 +00004033/*
drh4b70f112004-05-02 21:12:19 +00004034** Change the pParent pointer of all children of pPage to point back
4035** to pPage.
4036**
drhbd03cae2001-06-02 02:40:57 +00004037** In other words, for every child of pPage, invoke reparentPage()
drh5e00f6c2001-09-13 13:46:56 +00004038** to make sure that each child knows that pPage is its parent.
drhbd03cae2001-06-02 02:40:57 +00004039**
4040** This routine gets called after you memcpy() one page into
4041** another.
4042*/
danielk1977afcdd022004-10-31 16:25:42 +00004043static int reparentChildPages(MemPage *pPage){
drhbd03cae2001-06-02 02:40:57 +00004044 int i;
danielk1977aef0bf62005-12-30 16:28:01 +00004045 BtShared *pBt = pPage->pBt;
danielk1977afcdd022004-10-31 16:25:42 +00004046 int rc = SQLITE_OK;
drh4b70f112004-05-02 21:12:19 +00004047
danielk1977afcdd022004-10-31 16:25:42 +00004048 if( pPage->leaf ) return SQLITE_OK;
danielk1977afcdd022004-10-31 16:25:42 +00004049
drhbd03cae2001-06-02 02:40:57 +00004050 for(i=0; i<pPage->nCell; i++){
danielk1977afcdd022004-10-31 16:25:42 +00004051 u8 *pCell = findCell(pPage, i);
4052 if( !pPage->leaf ){
4053 rc = reparentPage(pBt, get4byte(pCell), pPage, i);
4054 if( rc!=SQLITE_OK ) return rc;
4055 }
drhbd03cae2001-06-02 02:40:57 +00004056 }
danielk1977afcdd022004-10-31 16:25:42 +00004057 if( !pPage->leaf ){
4058 rc = reparentPage(pBt, get4byte(&pPage->aData[pPage->hdrOffset+8]),
4059 pPage, i);
4060 pPage->idxShift = 0;
4061 }
4062 return rc;
drh14acc042001-06-10 19:56:58 +00004063}
4064
4065/*
4066** Remove the i-th cell from pPage. This routine effects pPage only.
4067** The cell content is not freed or deallocated. It is assumed that
4068** the cell content has been copied someplace else. This routine just
4069** removes the reference to the cell from pPage.
4070**
4071** "sz" must be the number of bytes in the cell.
drh14acc042001-06-10 19:56:58 +00004072*/
drh4b70f112004-05-02 21:12:19 +00004073static void dropCell(MemPage *pPage, int idx, int sz){
drh43605152004-05-29 21:46:49 +00004074 int i; /* Loop counter */
4075 int pc; /* Offset to cell content of cell being deleted */
4076 u8 *data; /* pPage->aData */
4077 u8 *ptr; /* Used to move bytes around within data[] */
4078
drh8c42ca92001-06-22 19:15:00 +00004079 assert( idx>=0 && idx<pPage->nCell );
drh43605152004-05-29 21:46:49 +00004080 assert( sz==cellSize(pPage, idx) );
drha34b6762004-05-07 13:30:42 +00004081 assert( sqlite3pager_iswriteable(pPage->aData) );
drhda200cc2004-05-09 11:51:38 +00004082 data = pPage->aData;
drh43605152004-05-29 21:46:49 +00004083 ptr = &data[pPage->cellOffset + 2*idx];
4084 pc = get2byte(ptr);
4085 assert( pc>10 && pc+sz<=pPage->pBt->usableSize );
drhde647132004-05-07 17:57:49 +00004086 freeSpace(pPage, pc, sz);
drh43605152004-05-29 21:46:49 +00004087 for(i=idx+1; i<pPage->nCell; i++, ptr+=2){
4088 ptr[0] = ptr[2];
4089 ptr[1] = ptr[3];
drh14acc042001-06-10 19:56:58 +00004090 }
4091 pPage->nCell--;
drh43605152004-05-29 21:46:49 +00004092 put2byte(&data[pPage->hdrOffset+3], pPage->nCell);
4093 pPage->nFree += 2;
drh428ae8c2003-01-04 16:48:09 +00004094 pPage->idxShift = 1;
drh14acc042001-06-10 19:56:58 +00004095}
4096
4097/*
4098** Insert a new cell on pPage at cell index "i". pCell points to the
4099** content of the cell.
4100**
4101** If the cell content will fit on the page, then put it there. If it
drh43605152004-05-29 21:46:49 +00004102** will not fit, then make a copy of the cell content into pTemp if
4103** pTemp is not null. Regardless of pTemp, allocate a new entry
4104** in pPage->aOvfl[] and make it point to the cell content (either
4105** in pTemp or the original pCell) and also record its index.
4106** Allocating a new entry in pPage->aCell[] implies that
4107** pPage->nOverflow is incremented.
danielk1977a3ad5e72005-01-07 08:56:44 +00004108**
4109** If nSkip is non-zero, then do not copy the first nSkip bytes of the
4110** cell. The caller will overwrite them after this function returns. If
drh4b238df2005-01-08 15:43:18 +00004111** nSkip is non-zero, then pCell may not point to an invalid memory location
danielk1977a3ad5e72005-01-07 08:56:44 +00004112** (but pCell+nSkip is always valid).
drh14acc042001-06-10 19:56:58 +00004113*/
danielk1977e80463b2004-11-03 03:01:16 +00004114static int insertCell(
drh24cd67e2004-05-10 16:18:47 +00004115 MemPage *pPage, /* Page into which we are copying */
drh43605152004-05-29 21:46:49 +00004116 int i, /* New cell becomes the i-th cell of the page */
4117 u8 *pCell, /* Content of the new cell */
4118 int sz, /* Bytes of content in pCell */
danielk1977a3ad5e72005-01-07 08:56:44 +00004119 u8 *pTemp, /* Temp storage space for pCell, if needed */
4120 u8 nSkip /* Do not write the first nSkip bytes of the cell */
drh24cd67e2004-05-10 16:18:47 +00004121){
drh43605152004-05-29 21:46:49 +00004122 int idx; /* Where to write new cell content in data[] */
4123 int j; /* Loop counter */
4124 int top; /* First byte of content for any cell in data[] */
4125 int end; /* First byte past the last cell pointer in data[] */
4126 int ins; /* Index in data[] where new cell pointer is inserted */
4127 int hdr; /* Offset into data[] of the page header */
4128 int cellOffset; /* Address of first cell pointer in data[] */
4129 u8 *data; /* The content of the whole page */
4130 u8 *ptr; /* Used for moving information around in data[] */
4131
4132 assert( i>=0 && i<=pPage->nCell+pPage->nOverflow );
4133 assert( sz==cellSizePtr(pPage, pCell) );
drha34b6762004-05-07 13:30:42 +00004134 assert( sqlite3pager_iswriteable(pPage->aData) );
drh43605152004-05-29 21:46:49 +00004135 if( pPage->nOverflow || sz+2>pPage->nFree ){
drh24cd67e2004-05-10 16:18:47 +00004136 if( pTemp ){
danielk1977a3ad5e72005-01-07 08:56:44 +00004137 memcpy(pTemp+nSkip, pCell+nSkip, sz-nSkip);
drh43605152004-05-29 21:46:49 +00004138 pCell = pTemp;
drh24cd67e2004-05-10 16:18:47 +00004139 }
drh43605152004-05-29 21:46:49 +00004140 j = pPage->nOverflow++;
4141 assert( j<sizeof(pPage->aOvfl)/sizeof(pPage->aOvfl[0]) );
4142 pPage->aOvfl[j].pCell = pCell;
4143 pPage->aOvfl[j].idx = i;
4144 pPage->nFree = 0;
drh14acc042001-06-10 19:56:58 +00004145 }else{
drh43605152004-05-29 21:46:49 +00004146 data = pPage->aData;
4147 hdr = pPage->hdrOffset;
4148 top = get2byte(&data[hdr+5]);
4149 cellOffset = pPage->cellOffset;
4150 end = cellOffset + 2*pPage->nCell + 2;
4151 ins = cellOffset + 2*i;
4152 if( end > top - sz ){
danielk19776b456a22005-03-21 04:04:02 +00004153 int rc = defragmentPage(pPage);
4154 if( rc!=SQLITE_OK ) return rc;
drh43605152004-05-29 21:46:49 +00004155 top = get2byte(&data[hdr+5]);
4156 assert( end + sz <= top );
4157 }
4158 idx = allocateSpace(pPage, sz);
4159 assert( idx>0 );
4160 assert( end <= get2byte(&data[hdr+5]) );
4161 pPage->nCell++;
4162 pPage->nFree -= 2;
danielk1977a3ad5e72005-01-07 08:56:44 +00004163 memcpy(&data[idx+nSkip], pCell+nSkip, sz-nSkip);
drh43605152004-05-29 21:46:49 +00004164 for(j=end-2, ptr=&data[j]; j>ins; j-=2, ptr-=2){
4165 ptr[0] = ptr[-2];
4166 ptr[1] = ptr[-1];
drhda200cc2004-05-09 11:51:38 +00004167 }
drh43605152004-05-29 21:46:49 +00004168 put2byte(&data[ins], idx);
4169 put2byte(&data[hdr+3], pPage->nCell);
4170 pPage->idxShift = 1;
danielk1977a19df672004-11-03 11:37:07 +00004171#ifndef SQLITE_OMIT_AUTOVACUUM
4172 if( pPage->pBt->autoVacuum ){
4173 /* The cell may contain a pointer to an overflow page. If so, write
4174 ** the entry for the overflow page into the pointer map.
4175 */
4176 CellInfo info;
4177 parseCellPtr(pPage, pCell, &info);
4178 if( (info.nData+(pPage->intKey?0:info.nKey))>info.nLocal ){
4179 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
4180 int rc = ptrmapPut(pPage->pBt, pgnoOvfl, PTRMAP_OVERFLOW1, pPage->pgno);
4181 if( rc!=SQLITE_OK ) return rc;
4182 }
4183 }
4184#endif
drh14acc042001-06-10 19:56:58 +00004185 }
danielk1977e80463b2004-11-03 03:01:16 +00004186
danielk1977e80463b2004-11-03 03:01:16 +00004187 return SQLITE_OK;
drh14acc042001-06-10 19:56:58 +00004188}
4189
4190/*
drhfa1a98a2004-05-14 19:08:17 +00004191** Add a list of cells to a page. The page should be initially empty.
4192** The cells are guaranteed to fit on the page.
4193*/
4194static void assemblePage(
4195 MemPage *pPage, /* The page to be assemblied */
4196 int nCell, /* The number of cells to add to this page */
drh43605152004-05-29 21:46:49 +00004197 u8 **apCell, /* Pointers to cell bodies */
drhfa1a98a2004-05-14 19:08:17 +00004198 int *aSize /* Sizes of the cells */
4199){
4200 int i; /* Loop counter */
4201 int totalSize; /* Total size of all cells */
4202 int hdr; /* Index of page header */
drh43605152004-05-29 21:46:49 +00004203 int cellptr; /* Address of next cell pointer */
4204 int cellbody; /* Address of next cell body */
drhfa1a98a2004-05-14 19:08:17 +00004205 u8 *data; /* Data for the page */
4206
drh43605152004-05-29 21:46:49 +00004207 assert( pPage->nOverflow==0 );
drhfa1a98a2004-05-14 19:08:17 +00004208 totalSize = 0;
4209 for(i=0; i<nCell; i++){
4210 totalSize += aSize[i];
4211 }
drh43605152004-05-29 21:46:49 +00004212 assert( totalSize+2*nCell<=pPage->nFree );
drhfa1a98a2004-05-14 19:08:17 +00004213 assert( pPage->nCell==0 );
drh43605152004-05-29 21:46:49 +00004214 cellptr = pPage->cellOffset;
drhfa1a98a2004-05-14 19:08:17 +00004215 data = pPage->aData;
4216 hdr = pPage->hdrOffset;
drh43605152004-05-29 21:46:49 +00004217 put2byte(&data[hdr+3], nCell);
drh09d0deb2005-08-02 17:13:09 +00004218 if( nCell ){
4219 cellbody = allocateSpace(pPage, totalSize);
4220 assert( cellbody>0 );
4221 assert( pPage->nFree >= 2*nCell );
4222 pPage->nFree -= 2*nCell;
4223 for(i=0; i<nCell; i++){
4224 put2byte(&data[cellptr], cellbody);
4225 memcpy(&data[cellbody], apCell[i], aSize[i]);
4226 cellptr += 2;
4227 cellbody += aSize[i];
4228 }
4229 assert( cellbody==pPage->pBt->usableSize );
drhfa1a98a2004-05-14 19:08:17 +00004230 }
4231 pPage->nCell = nCell;
drhfa1a98a2004-05-14 19:08:17 +00004232}
4233
drh14acc042001-06-10 19:56:58 +00004234/*
drhc3b70572003-01-04 19:44:07 +00004235** The following parameters determine how many adjacent pages get involved
4236** in a balancing operation. NN is the number of neighbors on either side
4237** of the page that participate in the balancing operation. NB is the
4238** total number of pages that participate, including the target page and
4239** NN neighbors on either side.
4240**
4241** The minimum value of NN is 1 (of course). Increasing NN above 1
4242** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance
4243** in exchange for a larger degradation in INSERT and UPDATE performance.
4244** The value of NN appears to give the best results overall.
4245*/
4246#define NN 1 /* Number of neighbors on either side of pPage */
4247#define NB (NN*2+1) /* Total pages involved in the balance */
4248
drh43605152004-05-29 21:46:49 +00004249/* Forward reference */
danielk1977ac245ec2005-01-14 13:50:11 +00004250static int balance(MemPage*, int);
4251
drh615ae552005-01-16 23:21:00 +00004252#ifndef SQLITE_OMIT_QUICKBALANCE
drhf222e712005-01-14 22:55:49 +00004253/*
4254** This version of balance() handles the common special case where
4255** a new entry is being inserted on the extreme right-end of the
4256** tree, in other words, when the new entry will become the largest
4257** entry in the tree.
4258**
4259** Instead of trying balance the 3 right-most leaf pages, just add
4260** a new page to the right-hand side and put the one new entry in
4261** that page. This leaves the right side of the tree somewhat
4262** unbalanced. But odds are that we will be inserting new entries
4263** at the end soon afterwards so the nearly empty page will quickly
4264** fill up. On average.
4265**
4266** pPage is the leaf page which is the right-most page in the tree.
4267** pParent is its parent. pPage must have a single overflow entry
4268** which is also the right-most entry on the page.
4269*/
danielk1977ac245ec2005-01-14 13:50:11 +00004270static int balance_quick(MemPage *pPage, MemPage *pParent){
4271 int rc;
4272 MemPage *pNew;
4273 Pgno pgnoNew;
4274 u8 *pCell;
4275 int szCell;
4276 CellInfo info;
danielk1977aef0bf62005-12-30 16:28:01 +00004277 BtShared *pBt = pPage->pBt;
danielk197779a40da2005-01-16 08:00:01 +00004278 int parentIdx = pParent->nCell; /* pParent new divider cell index */
4279 int parentSize; /* Size of new divider cell */
4280 u8 parentCell[64]; /* Space for the new divider cell */
danielk1977ac245ec2005-01-14 13:50:11 +00004281
4282 /* Allocate a new page. Insert the overflow cell from pPage
4283 ** into it. Then remove the overflow cell from pPage.
4284 */
danielk1977ac11ee62005-01-15 12:45:51 +00004285 rc = allocatePage(pBt, &pNew, &pgnoNew, 0, 0);
danielk1977ac245ec2005-01-14 13:50:11 +00004286 if( rc!=SQLITE_OK ){
4287 return rc;
4288 }
4289 pCell = pPage->aOvfl[0].pCell;
4290 szCell = cellSizePtr(pPage, pCell);
4291 zeroPage(pNew, pPage->aData[0]);
4292 assemblePage(pNew, 1, &pCell, &szCell);
4293 pPage->nOverflow = 0;
4294
danielk197779a40da2005-01-16 08:00:01 +00004295 /* Set the parent of the newly allocated page to pParent. */
4296 pNew->pParent = pParent;
4297 sqlite3pager_ref(pParent->aData);
4298
danielk1977ac245ec2005-01-14 13:50:11 +00004299 /* pPage is currently the right-child of pParent. Change this
4300 ** so that the right-child is the new page allocated above and
danielk197779a40da2005-01-16 08:00:01 +00004301 ** pPage is the next-to-right child.
danielk1977ac245ec2005-01-14 13:50:11 +00004302 */
danielk1977ac11ee62005-01-15 12:45:51 +00004303 assert( pPage->nCell>0 );
danielk1977ac245ec2005-01-14 13:50:11 +00004304 parseCellPtr(pPage, findCell(pPage, pPage->nCell-1), &info);
4305 rc = fillInCell(pParent, parentCell, 0, info.nKey, 0, 0, &parentSize);
4306 if( rc!=SQLITE_OK ){
danielk197779a40da2005-01-16 08:00:01 +00004307 return rc;
danielk1977ac245ec2005-01-14 13:50:11 +00004308 }
4309 assert( parentSize<64 );
4310 rc = insertCell(pParent, parentIdx, parentCell, parentSize, 0, 4);
4311 if( rc!=SQLITE_OK ){
danielk197779a40da2005-01-16 08:00:01 +00004312 return rc;
danielk1977ac245ec2005-01-14 13:50:11 +00004313 }
4314 put4byte(findOverflowCell(pParent,parentIdx), pPage->pgno);
4315 put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew);
4316
danielk197779a40da2005-01-16 08:00:01 +00004317#ifndef SQLITE_OMIT_AUTOVACUUM
4318 /* If this is an auto-vacuum database, update the pointer map
4319 ** with entries for the new page, and any pointer from the
4320 ** cell on the page to an overflow page.
4321 */
danielk1977ac11ee62005-01-15 12:45:51 +00004322 if( pBt->autoVacuum ){
4323 rc = ptrmapPut(pBt, pgnoNew, PTRMAP_BTREE, pParent->pgno);
4324 if( rc!=SQLITE_OK ){
4325 return rc;
4326 }
danielk197779a40da2005-01-16 08:00:01 +00004327 rc = ptrmapPutOvfl(pNew, 0);
4328 if( rc!=SQLITE_OK ){
4329 return rc;
danielk1977ac11ee62005-01-15 12:45:51 +00004330 }
4331 }
danielk197779a40da2005-01-16 08:00:01 +00004332#endif
danielk1977ac11ee62005-01-15 12:45:51 +00004333
danielk197779a40da2005-01-16 08:00:01 +00004334 /* Release the reference to the new page and balance the parent page,
4335 ** in case the divider cell inserted caused it to become overfull.
4336 */
danielk1977ac245ec2005-01-14 13:50:11 +00004337 releasePage(pNew);
4338 return balance(pParent, 0);
4339}
drh615ae552005-01-16 23:21:00 +00004340#endif /* SQLITE_OMIT_QUICKBALANCE */
drh43605152004-05-29 21:46:49 +00004341
drhc3b70572003-01-04 19:44:07 +00004342/*
danielk1977ac11ee62005-01-15 12:45:51 +00004343** The ISAUTOVACUUM macro is used within balance_nonroot() to determine
4344** if the database supports auto-vacuum or not. Because it is used
4345** within an expression that is an argument to another macro
4346** (sqliteMallocRaw), it is not possible to use conditional compilation.
4347** So, this macro is defined instead.
4348*/
4349#ifndef SQLITE_OMIT_AUTOVACUUM
4350#define ISAUTOVACUUM (pBt->autoVacuum)
4351#else
4352#define ISAUTOVACUUM 0
4353#endif
4354
4355/*
drhab01f612004-05-22 02:55:23 +00004356** This routine redistributes Cells on pPage and up to NN*2 siblings
drh8b2f49b2001-06-08 00:21:52 +00004357** of pPage so that all pages have about the same amount of free space.
drh0c6cc4e2004-06-15 02:13:26 +00004358** Usually NN siblings on either side of pPage is used in the balancing,
4359** though more siblings might come from one side if pPage is the first
drhab01f612004-05-22 02:55:23 +00004360** or last child of its parent. If pPage has fewer than 2*NN siblings
drh8b2f49b2001-06-08 00:21:52 +00004361** (something which can only happen if pPage is the root page or a
drh14acc042001-06-10 19:56:58 +00004362** child of root) then all available siblings participate in the balancing.
drh8b2f49b2001-06-08 00:21:52 +00004363**
drh0c6cc4e2004-06-15 02:13:26 +00004364** The number of siblings of pPage might be increased or decreased by one or
4365** two in an effort to keep pages nearly full but not over full. The root page
drhab01f612004-05-22 02:55:23 +00004366** is special and is allowed to be nearly empty. If pPage is
drh8c42ca92001-06-22 19:15:00 +00004367** the root page, then the depth of the tree might be increased
drh8b2f49b2001-06-08 00:21:52 +00004368** or decreased by one, as necessary, to keep the root page from being
drhab01f612004-05-22 02:55:23 +00004369** overfull or completely empty.
drh14acc042001-06-10 19:56:58 +00004370**
drh8b2f49b2001-06-08 00:21:52 +00004371** Note that when this routine is called, some of the Cells on pPage
drh4b70f112004-05-02 21:12:19 +00004372** might not actually be stored in pPage->aData[]. This can happen
drh8b2f49b2001-06-08 00:21:52 +00004373** if the page is overfull. Part of the job of this routine is to
drh4b70f112004-05-02 21:12:19 +00004374** make sure all Cells for pPage once again fit in pPage->aData[].
drh14acc042001-06-10 19:56:58 +00004375**
drh8c42ca92001-06-22 19:15:00 +00004376** In the course of balancing the siblings of pPage, the parent of pPage
4377** might become overfull or underfull. If that happens, then this routine
4378** is called recursively on the parent.
4379**
drh5e00f6c2001-09-13 13:46:56 +00004380** If this routine fails for any reason, it might leave the database
4381** in a corrupted state. So if this routine fails, the database should
4382** be rolled back.
drh8b2f49b2001-06-08 00:21:52 +00004383*/
drh43605152004-05-29 21:46:49 +00004384static int balance_nonroot(MemPage *pPage){
drh8b2f49b2001-06-08 00:21:52 +00004385 MemPage *pParent; /* The parent of pPage */
danielk1977aef0bf62005-12-30 16:28:01 +00004386 BtShared *pBt; /* The whole database */
danielk1977634f2982005-03-28 08:44:07 +00004387 int nCell = 0; /* Number of cells in apCell[] */
4388 int nMaxCells = 0; /* Allocated size of apCell, szCell, aFrom. */
drh8b2f49b2001-06-08 00:21:52 +00004389 int nOld; /* Number of pages in apOld[] */
4390 int nNew; /* Number of pages in apNew[] */
drh8b2f49b2001-06-08 00:21:52 +00004391 int nDiv; /* Number of cells in apDiv[] */
drh14acc042001-06-10 19:56:58 +00004392 int i, j, k; /* Loop counters */
drha34b6762004-05-07 13:30:42 +00004393 int idx; /* Index of pPage in pParent->aCell[] */
4394 int nxDiv; /* Next divider slot in pParent->aCell[] */
drh14acc042001-06-10 19:56:58 +00004395 int rc; /* The return code */
drh91025292004-05-03 19:49:32 +00004396 int leafCorrection; /* 4 if pPage is a leaf. 0 if not */
drh8b18dd42004-05-12 19:18:15 +00004397 int leafData; /* True if pPage is a leaf of a LEAFDATA tree */
drh91025292004-05-03 19:49:32 +00004398 int usableSpace; /* Bytes in pPage beyond the header */
4399 int pageFlags; /* Value of pPage->aData[0] */
drh6019e162001-07-02 17:51:45 +00004400 int subtotal; /* Subtotal of bytes in cells on one page */
drhb6f41482004-05-14 01:58:11 +00004401 int iSpace = 0; /* First unused byte of aSpace[] */
drhc3b70572003-01-04 19:44:07 +00004402 MemPage *apOld[NB]; /* pPage and up to two siblings */
4403 Pgno pgnoOld[NB]; /* Page numbers for each page in apOld[] */
drh4b70f112004-05-02 21:12:19 +00004404 MemPage *apCopy[NB]; /* Private copies of apOld[] pages */
drha2fce642004-06-05 00:01:44 +00004405 MemPage *apNew[NB+2]; /* pPage and up to NB siblings after balancing */
4406 Pgno pgnoNew[NB+2]; /* Page numbers for each page in apNew[] */
drh4b70f112004-05-02 21:12:19 +00004407 u8 *apDiv[NB]; /* Divider cells in pParent */
drha2fce642004-06-05 00:01:44 +00004408 int cntNew[NB+2]; /* Index in aCell[] of cell after i-th page */
4409 int szNew[NB+2]; /* Combined size of cells place on i-th page */
danielk197750f059b2005-03-29 02:54:03 +00004410 u8 **apCell = 0; /* All cells begin balanced */
drh2e38c322004-09-03 18:38:44 +00004411 int *szCell; /* Local size of all cells in apCell[] */
4412 u8 *aCopy[NB]; /* Space for holding data of apCopy[] */
4413 u8 *aSpace; /* Space to hold copies of dividers cells */
danielk19774e17d142005-01-16 09:06:33 +00004414#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977ac11ee62005-01-15 12:45:51 +00004415 u8 *aFrom = 0;
4416#endif
drh8b2f49b2001-06-08 00:21:52 +00004417
drh14acc042001-06-10 19:56:58 +00004418 /*
drh43605152004-05-29 21:46:49 +00004419 ** Find the parent page.
drh8b2f49b2001-06-08 00:21:52 +00004420 */
drh3a4c1412004-05-09 20:40:11 +00004421 assert( pPage->isInit );
drha34b6762004-05-07 13:30:42 +00004422 assert( sqlite3pager_iswriteable(pPage->aData) );
drh4b70f112004-05-02 21:12:19 +00004423 pBt = pPage->pBt;
drh14acc042001-06-10 19:56:58 +00004424 pParent = pPage->pParent;
drh43605152004-05-29 21:46:49 +00004425 assert( pParent );
danielk197707cb5602006-01-20 10:55:05 +00004426 if( SQLITE_OK!=(rc = sqlite3pager_write(pParent->aData)) ){
4427 return rc;
4428 }
drh43605152004-05-29 21:46:49 +00004429 TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
drh2e38c322004-09-03 18:38:44 +00004430
drh615ae552005-01-16 23:21:00 +00004431#ifndef SQLITE_OMIT_QUICKBALANCE
drhf222e712005-01-14 22:55:49 +00004432 /*
4433 ** A special case: If a new entry has just been inserted into a
4434 ** table (that is, a btree with integer keys and all data at the leaves)
drh09d0deb2005-08-02 17:13:09 +00004435 ** and the new entry is the right-most entry in the tree (it has the
drhf222e712005-01-14 22:55:49 +00004436 ** largest key) then use the special balance_quick() routine for
4437 ** balancing. balance_quick() is much faster and results in a tighter
4438 ** packing of data in the common case.
4439 */
danielk1977ac245ec2005-01-14 13:50:11 +00004440 if( pPage->leaf &&
4441 pPage->intKey &&
4442 pPage->leafData &&
4443 pPage->nOverflow==1 &&
4444 pPage->aOvfl[0].idx==pPage->nCell &&
danielk1977ac11ee62005-01-15 12:45:51 +00004445 pPage->pParent->pgno!=1 &&
danielk1977ac245ec2005-01-14 13:50:11 +00004446 get4byte(&pParent->aData[pParent->hdrOffset+8])==pPage->pgno
4447 ){
danielk1977ac11ee62005-01-15 12:45:51 +00004448 /*
4449 ** TODO: Check the siblings to the left of pPage. It may be that
4450 ** they are not full and no new page is required.
4451 */
danielk1977ac245ec2005-01-14 13:50:11 +00004452 return balance_quick(pPage, pParent);
4453 }
4454#endif
4455
drh2e38c322004-09-03 18:38:44 +00004456 /*
drh4b70f112004-05-02 21:12:19 +00004457 ** Find the cell in the parent page whose left child points back
drh14acc042001-06-10 19:56:58 +00004458 ** to pPage. The "idx" variable is the index of that cell. If pPage
4459 ** is the rightmost child of pParent then set idx to pParent->nCell
drh8b2f49b2001-06-08 00:21:52 +00004460 */
drhbb49aba2003-01-04 18:53:27 +00004461 if( pParent->idxShift ){
drha34b6762004-05-07 13:30:42 +00004462 Pgno pgno;
drh4b70f112004-05-02 21:12:19 +00004463 pgno = pPage->pgno;
drha34b6762004-05-07 13:30:42 +00004464 assert( pgno==sqlite3pager_pagenumber(pPage->aData) );
drhbb49aba2003-01-04 18:53:27 +00004465 for(idx=0; idx<pParent->nCell; idx++){
drh43605152004-05-29 21:46:49 +00004466 if( get4byte(findCell(pParent, idx))==pgno ){
drhbb49aba2003-01-04 18:53:27 +00004467 break;
4468 }
drh8b2f49b2001-06-08 00:21:52 +00004469 }
drh4b70f112004-05-02 21:12:19 +00004470 assert( idx<pParent->nCell
drh43605152004-05-29 21:46:49 +00004471 || get4byte(&pParent->aData[pParent->hdrOffset+8])==pgno );
drhbb49aba2003-01-04 18:53:27 +00004472 }else{
4473 idx = pPage->idxParent;
drh8b2f49b2001-06-08 00:21:52 +00004474 }
drh8b2f49b2001-06-08 00:21:52 +00004475
4476 /*
drh14acc042001-06-10 19:56:58 +00004477 ** Initialize variables so that it will be safe to jump
drh5edc3122001-09-13 21:53:09 +00004478 ** directly to balance_cleanup at any moment.
drh8b2f49b2001-06-08 00:21:52 +00004479 */
drh14acc042001-06-10 19:56:58 +00004480 nOld = nNew = 0;
drha34b6762004-05-07 13:30:42 +00004481 sqlite3pager_ref(pParent->aData);
drh14acc042001-06-10 19:56:58 +00004482
4483 /*
drh4b70f112004-05-02 21:12:19 +00004484 ** Find sibling pages to pPage and the cells in pParent that divide
drhc3b70572003-01-04 19:44:07 +00004485 ** the siblings. An attempt is made to find NN siblings on either
4486 ** side of pPage. More siblings are taken from one side, however, if
4487 ** pPage there are fewer than NN siblings on the other side. If pParent
4488 ** has NB or fewer children then all children of pParent are taken.
drh14acc042001-06-10 19:56:58 +00004489 */
drhc3b70572003-01-04 19:44:07 +00004490 nxDiv = idx - NN;
4491 if( nxDiv + NB > pParent->nCell ){
4492 nxDiv = pParent->nCell - NB + 1;
drh8b2f49b2001-06-08 00:21:52 +00004493 }
drhc3b70572003-01-04 19:44:07 +00004494 if( nxDiv<0 ){
4495 nxDiv = 0;
4496 }
drh8b2f49b2001-06-08 00:21:52 +00004497 nDiv = 0;
drhc3b70572003-01-04 19:44:07 +00004498 for(i=0, k=nxDiv; i<NB; i++, k++){
drh14acc042001-06-10 19:56:58 +00004499 if( k<pParent->nCell ){
drh43605152004-05-29 21:46:49 +00004500 apDiv[i] = findCell(pParent, k);
drh8b2f49b2001-06-08 00:21:52 +00004501 nDiv++;
drha34b6762004-05-07 13:30:42 +00004502 assert( !pParent->leaf );
drh43605152004-05-29 21:46:49 +00004503 pgnoOld[i] = get4byte(apDiv[i]);
drh14acc042001-06-10 19:56:58 +00004504 }else if( k==pParent->nCell ){
drh43605152004-05-29 21:46:49 +00004505 pgnoOld[i] = get4byte(&pParent->aData[pParent->hdrOffset+8]);
drh14acc042001-06-10 19:56:58 +00004506 }else{
4507 break;
drh8b2f49b2001-06-08 00:21:52 +00004508 }
drhde647132004-05-07 17:57:49 +00004509 rc = getAndInitPage(pBt, pgnoOld[i], &apOld[i], pParent);
drh6019e162001-07-02 17:51:45 +00004510 if( rc ) goto balance_cleanup;
drh428ae8c2003-01-04 16:48:09 +00004511 apOld[i]->idxParent = k;
drh91025292004-05-03 19:49:32 +00004512 apCopy[i] = 0;
4513 assert( i==nOld );
drh14acc042001-06-10 19:56:58 +00004514 nOld++;
danielk1977634f2982005-03-28 08:44:07 +00004515 nMaxCells += 1+apOld[i]->nCell+apOld[i]->nOverflow;
drh8b2f49b2001-06-08 00:21:52 +00004516 }
4517
drh8d97f1f2005-05-05 18:14:13 +00004518 /* Make nMaxCells a multiple of 2 in order to preserve 8-byte
4519 ** alignment */
4520 nMaxCells = (nMaxCells + 1)&~1;
4521
drh8b2f49b2001-06-08 00:21:52 +00004522 /*
danielk1977634f2982005-03-28 08:44:07 +00004523 ** Allocate space for memory structures
4524 */
4525 apCell = sqliteMallocRaw(
4526 nMaxCells*sizeof(u8*) /* apCell */
4527 + nMaxCells*sizeof(int) /* szCell */
drhc96d8532005-05-03 12:30:33 +00004528 + ROUND8(sizeof(MemPage))*NB /* aCopy */
drh07d183d2005-05-01 22:52:42 +00004529 + pBt->pageSize*(5+NB) /* aSpace */
drhc96d8532005-05-03 12:30:33 +00004530 + (ISAUTOVACUUM ? nMaxCells : 0) /* aFrom */
danielk1977634f2982005-03-28 08:44:07 +00004531 );
4532 if( apCell==0 ){
4533 rc = SQLITE_NOMEM;
4534 goto balance_cleanup;
4535 }
4536 szCell = (int*)&apCell[nMaxCells];
4537 aCopy[0] = (u8*)&szCell[nMaxCells];
drhc96d8532005-05-03 12:30:33 +00004538 assert( ((aCopy[0] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */
danielk1977634f2982005-03-28 08:44:07 +00004539 for(i=1; i<NB; i++){
drhc96d8532005-05-03 12:30:33 +00004540 aCopy[i] = &aCopy[i-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
4541 assert( ((aCopy[i] - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */
danielk1977634f2982005-03-28 08:44:07 +00004542 }
drhc96d8532005-05-03 12:30:33 +00004543 aSpace = &aCopy[NB-1][pBt->pageSize+ROUND8(sizeof(MemPage))];
4544 assert( ((aSpace - (u8*)apCell) & 7)==0 ); /* 8-byte alignment required */
danielk1977634f2982005-03-28 08:44:07 +00004545#ifndef SQLITE_OMIT_AUTOVACUUM
4546 if( pBt->autoVacuum ){
drh07d183d2005-05-01 22:52:42 +00004547 aFrom = &aSpace[5*pBt->pageSize];
danielk1977634f2982005-03-28 08:44:07 +00004548 }
4549#endif
4550
4551 /*
drh14acc042001-06-10 19:56:58 +00004552 ** Make copies of the content of pPage and its siblings into aOld[].
4553 ** The rest of this function will use data from the copies rather
4554 ** that the original pages since the original pages will be in the
4555 ** process of being overwritten.
4556 */
4557 for(i=0; i<nOld; i++){
drh07d183d2005-05-01 22:52:42 +00004558 MemPage *p = apCopy[i] = (MemPage*)&aCopy[i][pBt->pageSize];
drh07d183d2005-05-01 22:52:42 +00004559 p->aData = &((u8*)p)[-pBt->pageSize];
4560 memcpy(p->aData, apOld[i]->aData, pBt->pageSize + sizeof(MemPage));
4561 /* The memcpy() above changes the value of p->aData so we have to
4562 ** set it again. */
drh07d183d2005-05-01 22:52:42 +00004563 p->aData = &((u8*)p)[-pBt->pageSize];
drh14acc042001-06-10 19:56:58 +00004564 }
4565
4566 /*
4567 ** Load pointers to all cells on sibling pages and the divider cells
4568 ** into the local apCell[] array. Make copies of the divider cells
drhb6f41482004-05-14 01:58:11 +00004569 ** into space obtained form aSpace[] and remove the the divider Cells
4570 ** from pParent.
drh4b70f112004-05-02 21:12:19 +00004571 **
4572 ** If the siblings are on leaf pages, then the child pointers of the
4573 ** divider cells are stripped from the cells before they are copied
drh96f5b762004-05-16 16:24:36 +00004574 ** into aSpace[]. In this way, all cells in apCell[] are without
drh4b70f112004-05-02 21:12:19 +00004575 ** child pointers. If siblings are not leaves, then all cell in
4576 ** apCell[] include child pointers. Either way, all cells in apCell[]
4577 ** are alike.
drh96f5b762004-05-16 16:24:36 +00004578 **
4579 ** leafCorrection: 4 if pPage is a leaf. 0 if pPage is not a leaf.
4580 ** leafData: 1 if pPage holds key+data and pParent holds only keys.
drh8b2f49b2001-06-08 00:21:52 +00004581 */
4582 nCell = 0;
drh4b70f112004-05-02 21:12:19 +00004583 leafCorrection = pPage->leaf*4;
drh8b18dd42004-05-12 19:18:15 +00004584 leafData = pPage->leafData && pPage->leaf;
drh8b2f49b2001-06-08 00:21:52 +00004585 for(i=0; i<nOld; i++){
drh4b70f112004-05-02 21:12:19 +00004586 MemPage *pOld = apCopy[i];
drh43605152004-05-29 21:46:49 +00004587 int limit = pOld->nCell+pOld->nOverflow;
4588 for(j=0; j<limit; j++){
danielk1977634f2982005-03-28 08:44:07 +00004589 assert( nCell<nMaxCells );
drh43605152004-05-29 21:46:49 +00004590 apCell[nCell] = findOverflowCell(pOld, j);
4591 szCell[nCell] = cellSizePtr(pOld, apCell[nCell]);
danielk1977ac11ee62005-01-15 12:45:51 +00004592#ifndef SQLITE_OMIT_AUTOVACUUM
4593 if( pBt->autoVacuum ){
4594 int a;
4595 aFrom[nCell] = i;
4596 for(a=0; a<pOld->nOverflow; a++){
4597 if( pOld->aOvfl[a].pCell==apCell[nCell] ){
4598 aFrom[nCell] = 0xFF;
4599 break;
4600 }
4601 }
4602 }
4603#endif
drh14acc042001-06-10 19:56:58 +00004604 nCell++;
drh8b2f49b2001-06-08 00:21:52 +00004605 }
4606 if( i<nOld-1 ){
drh43605152004-05-29 21:46:49 +00004607 int sz = cellSizePtr(pParent, apDiv[i]);
drh8b18dd42004-05-12 19:18:15 +00004608 if( leafData ){
drh96f5b762004-05-16 16:24:36 +00004609 /* With the LEAFDATA flag, pParent cells hold only INTKEYs that
4610 ** are duplicates of keys on the child pages. We need to remove
4611 ** the divider cells from pParent, but the dividers cells are not
4612 ** added to apCell[] because they are duplicates of child cells.
4613 */
drh8b18dd42004-05-12 19:18:15 +00004614 dropCell(pParent, nxDiv, sz);
drh4b70f112004-05-02 21:12:19 +00004615 }else{
drhb6f41482004-05-14 01:58:11 +00004616 u8 *pTemp;
danielk1977634f2982005-03-28 08:44:07 +00004617 assert( nCell<nMaxCells );
drhb6f41482004-05-14 01:58:11 +00004618 szCell[nCell] = sz;
4619 pTemp = &aSpace[iSpace];
4620 iSpace += sz;
drh07d183d2005-05-01 22:52:42 +00004621 assert( iSpace<=pBt->pageSize*5 );
drhb6f41482004-05-14 01:58:11 +00004622 memcpy(pTemp, apDiv[i], sz);
4623 apCell[nCell] = pTemp+leafCorrection;
danielk1977ac11ee62005-01-15 12:45:51 +00004624#ifndef SQLITE_OMIT_AUTOVACUUM
4625 if( pBt->autoVacuum ){
4626 aFrom[nCell] = 0xFF;
4627 }
4628#endif
drhb6f41482004-05-14 01:58:11 +00004629 dropCell(pParent, nxDiv, sz);
drh8b18dd42004-05-12 19:18:15 +00004630 szCell[nCell] -= leafCorrection;
drh43605152004-05-29 21:46:49 +00004631 assert( get4byte(pTemp)==pgnoOld[i] );
drh8b18dd42004-05-12 19:18:15 +00004632 if( !pOld->leaf ){
4633 assert( leafCorrection==0 );
4634 /* The right pointer of the child page pOld becomes the left
4635 ** pointer of the divider cell */
drh43605152004-05-29 21:46:49 +00004636 memcpy(apCell[nCell], &pOld->aData[pOld->hdrOffset+8], 4);
drh8b18dd42004-05-12 19:18:15 +00004637 }else{
4638 assert( leafCorrection==4 );
4639 }
4640 nCell++;
drh4b70f112004-05-02 21:12:19 +00004641 }
drh8b2f49b2001-06-08 00:21:52 +00004642 }
4643 }
4644
4645 /*
drh6019e162001-07-02 17:51:45 +00004646 ** Figure out the number of pages needed to hold all nCell cells.
4647 ** Store this number in "k". Also compute szNew[] which is the total
4648 ** size of all cells on the i-th page and cntNew[] which is the index
drh4b70f112004-05-02 21:12:19 +00004649 ** in apCell[] of the cell that divides page i from page i+1.
drh6019e162001-07-02 17:51:45 +00004650 ** cntNew[k] should equal nCell.
4651 **
drh96f5b762004-05-16 16:24:36 +00004652 ** Values computed by this block:
4653 **
4654 ** k: The total number of sibling pages
4655 ** szNew[i]: Spaced used on the i-th sibling page.
4656 ** cntNew[i]: Index in apCell[] and szCell[] for the first cell to
4657 ** the right of the i-th sibling page.
4658 ** usableSpace: Number of bytes of space available on each sibling.
4659 **
drh8b2f49b2001-06-08 00:21:52 +00004660 */
drh43605152004-05-29 21:46:49 +00004661 usableSpace = pBt->usableSize - 12 + leafCorrection;
drh6019e162001-07-02 17:51:45 +00004662 for(subtotal=k=i=0; i<nCell; i++){
danielk1977634f2982005-03-28 08:44:07 +00004663 assert( i<nMaxCells );
drh43605152004-05-29 21:46:49 +00004664 subtotal += szCell[i] + 2;
drh4b70f112004-05-02 21:12:19 +00004665 if( subtotal > usableSpace ){
drh6019e162001-07-02 17:51:45 +00004666 szNew[k] = subtotal - szCell[i];
4667 cntNew[k] = i;
drh8b18dd42004-05-12 19:18:15 +00004668 if( leafData ){ i--; }
drh6019e162001-07-02 17:51:45 +00004669 subtotal = 0;
4670 k++;
4671 }
4672 }
4673 szNew[k] = subtotal;
4674 cntNew[k] = nCell;
4675 k++;
drh96f5b762004-05-16 16:24:36 +00004676
4677 /*
4678 ** The packing computed by the previous block is biased toward the siblings
4679 ** on the left side. The left siblings are always nearly full, while the
4680 ** right-most sibling might be nearly empty. This block of code attempts
4681 ** to adjust the packing of siblings to get a better balance.
4682 **
4683 ** This adjustment is more than an optimization. The packing above might
4684 ** be so out of balance as to be illegal. For example, the right-most
4685 ** sibling might be completely empty. This adjustment is not optional.
4686 */
drh6019e162001-07-02 17:51:45 +00004687 for(i=k-1; i>0; i--){
drh96f5b762004-05-16 16:24:36 +00004688 int szRight = szNew[i]; /* Size of sibling on the right */
4689 int szLeft = szNew[i-1]; /* Size of sibling on the left */
4690 int r; /* Index of right-most cell in left sibling */
4691 int d; /* Index of first cell to the left of right sibling */
4692
4693 r = cntNew[i-1] - 1;
4694 d = r + 1 - leafData;
danielk1977634f2982005-03-28 08:44:07 +00004695 assert( d<nMaxCells );
4696 assert( r<nMaxCells );
drh43605152004-05-29 21:46:49 +00004697 while( szRight==0 || szRight+szCell[d]+2<=szLeft-(szCell[r]+2) ){
4698 szRight += szCell[d] + 2;
4699 szLeft -= szCell[r] + 2;
drh6019e162001-07-02 17:51:45 +00004700 cntNew[i-1]--;
drh96f5b762004-05-16 16:24:36 +00004701 r = cntNew[i-1] - 1;
4702 d = r + 1 - leafData;
drh6019e162001-07-02 17:51:45 +00004703 }
drh96f5b762004-05-16 16:24:36 +00004704 szNew[i] = szRight;
4705 szNew[i-1] = szLeft;
drh6019e162001-07-02 17:51:45 +00004706 }
drh09d0deb2005-08-02 17:13:09 +00004707
4708 /* Either we found one or more cells (cntnew[0])>0) or we are the
4709 ** a virtual root page. A virtual root page is when the real root
4710 ** page is page 1 and we are the only child of that page.
4711 */
4712 assert( cntNew[0]>0 || (pParent->pgno==1 && pParent->nCell==0) );
drh8b2f49b2001-06-08 00:21:52 +00004713
4714 /*
drh6b308672002-07-08 02:16:37 +00004715 ** Allocate k new pages. Reuse old pages where possible.
drh8b2f49b2001-06-08 00:21:52 +00004716 */
drh4b70f112004-05-02 21:12:19 +00004717 assert( pPage->pgno>1 );
4718 pageFlags = pPage->aData[0];
drh14acc042001-06-10 19:56:58 +00004719 for(i=0; i<k; i++){
drhda200cc2004-05-09 11:51:38 +00004720 MemPage *pNew;
drh6b308672002-07-08 02:16:37 +00004721 if( i<nOld ){
drhda200cc2004-05-09 11:51:38 +00004722 pNew = apNew[i] = apOld[i];
drh6b308672002-07-08 02:16:37 +00004723 pgnoNew[i] = pgnoOld[i];
4724 apOld[i] = 0;
danielk197728129562005-01-11 10:25:06 +00004725 rc = sqlite3pager_write(pNew->aData);
4726 if( rc ) goto balance_cleanup;
drh6b308672002-07-08 02:16:37 +00004727 }else{
drh7aa8f852006-03-28 00:24:44 +00004728 assert( i>0 );
danielk1977cb1a7eb2004-11-05 12:27:02 +00004729 rc = allocatePage(pBt, &pNew, &pgnoNew[i], pgnoNew[i-1], 0);
drh6b308672002-07-08 02:16:37 +00004730 if( rc ) goto balance_cleanup;
drhda200cc2004-05-09 11:51:38 +00004731 apNew[i] = pNew;
drh6b308672002-07-08 02:16:37 +00004732 }
drh14acc042001-06-10 19:56:58 +00004733 nNew++;
drhda200cc2004-05-09 11:51:38 +00004734 zeroPage(pNew, pageFlags);
drh8b2f49b2001-06-08 00:21:52 +00004735 }
4736
danielk1977299b1872004-11-22 10:02:10 +00004737 /* Free any old pages that were not reused as new pages.
4738 */
4739 while( i<nOld ){
4740 rc = freePage(apOld[i]);
4741 if( rc ) goto balance_cleanup;
4742 releasePage(apOld[i]);
4743 apOld[i] = 0;
4744 i++;
4745 }
4746
drh8b2f49b2001-06-08 00:21:52 +00004747 /*
drhf9ffac92002-03-02 19:00:31 +00004748 ** Put the new pages in accending order. This helps to
4749 ** keep entries in the disk file in order so that a scan
4750 ** of the table is a linear scan through the file. That
4751 ** in turn helps the operating system to deliver pages
4752 ** from the disk more rapidly.
4753 **
4754 ** An O(n^2) insertion sort algorithm is used, but since
drhc3b70572003-01-04 19:44:07 +00004755 ** n is never more than NB (a small constant), that should
4756 ** not be a problem.
drhf9ffac92002-03-02 19:00:31 +00004757 **
drhc3b70572003-01-04 19:44:07 +00004758 ** When NB==3, this one optimization makes the database
4759 ** about 25% faster for large insertions and deletions.
drhf9ffac92002-03-02 19:00:31 +00004760 */
4761 for(i=0; i<k-1; i++){
4762 int minV = pgnoNew[i];
4763 int minI = i;
4764 for(j=i+1; j<k; j++){
drh7d02cb72003-06-04 16:24:39 +00004765 if( pgnoNew[j]<(unsigned)minV ){
drhf9ffac92002-03-02 19:00:31 +00004766 minI = j;
4767 minV = pgnoNew[j];
4768 }
4769 }
4770 if( minI>i ){
4771 int t;
4772 MemPage *pT;
4773 t = pgnoNew[i];
4774 pT = apNew[i];
4775 pgnoNew[i] = pgnoNew[minI];
4776 apNew[i] = apNew[minI];
4777 pgnoNew[minI] = t;
4778 apNew[minI] = pT;
4779 }
4780 }
drha2fce642004-06-05 00:01:44 +00004781 TRACE(("BALANCE: old: %d %d %d new: %d(%d) %d(%d) %d(%d) %d(%d) %d(%d)\n",
drh24cd67e2004-05-10 16:18:47 +00004782 pgnoOld[0],
4783 nOld>=2 ? pgnoOld[1] : 0,
4784 nOld>=3 ? pgnoOld[2] : 0,
drh10c0fa62004-05-18 12:50:17 +00004785 pgnoNew[0], szNew[0],
4786 nNew>=2 ? pgnoNew[1] : 0, nNew>=2 ? szNew[1] : 0,
4787 nNew>=3 ? pgnoNew[2] : 0, nNew>=3 ? szNew[2] : 0,
drha2fce642004-06-05 00:01:44 +00004788 nNew>=4 ? pgnoNew[3] : 0, nNew>=4 ? szNew[3] : 0,
4789 nNew>=5 ? pgnoNew[4] : 0, nNew>=5 ? szNew[4] : 0));
drh24cd67e2004-05-10 16:18:47 +00004790
drhf9ffac92002-03-02 19:00:31 +00004791 /*
drh14acc042001-06-10 19:56:58 +00004792 ** Evenly distribute the data in apCell[] across the new pages.
4793 ** Insert divider cells into pParent as necessary.
4794 */
4795 j = 0;
4796 for(i=0; i<nNew; i++){
danielk1977ac11ee62005-01-15 12:45:51 +00004797 /* Assemble the new sibling page. */
drh14acc042001-06-10 19:56:58 +00004798 MemPage *pNew = apNew[i];
drh19642e52005-03-29 13:17:45 +00004799 assert( j<nMaxCells );
drh4b70f112004-05-02 21:12:19 +00004800 assert( pNew->pgno==pgnoNew[i] );
drhfa1a98a2004-05-14 19:08:17 +00004801 assemblePage(pNew, cntNew[i]-j, &apCell[j], &szCell[j]);
drh09d0deb2005-08-02 17:13:09 +00004802 assert( pNew->nCell>0 || (nNew==1 && cntNew[0]==0) );
drh43605152004-05-29 21:46:49 +00004803 assert( pNew->nOverflow==0 );
danielk1977ac11ee62005-01-15 12:45:51 +00004804
4805#ifndef SQLITE_OMIT_AUTOVACUUM
4806 /* If this is an auto-vacuum database, update the pointer map entries
4807 ** that point to the siblings that were rearranged. These can be: left
4808 ** children of cells, the right-child of the page, or overflow pages
4809 ** pointed to by cells.
4810 */
4811 if( pBt->autoVacuum ){
4812 for(k=j; k<cntNew[i]; k++){
danielk1977634f2982005-03-28 08:44:07 +00004813 assert( k<nMaxCells );
danielk1977ac11ee62005-01-15 12:45:51 +00004814 if( aFrom[k]==0xFF || apCopy[aFrom[k]]->pgno!=pNew->pgno ){
danielk197779a40da2005-01-16 08:00:01 +00004815 rc = ptrmapPutOvfl(pNew, k-j);
4816 if( rc!=SQLITE_OK ){
4817 goto balance_cleanup;
danielk1977ac11ee62005-01-15 12:45:51 +00004818 }
4819 }
4820 }
4821 }
4822#endif
4823
4824 j = cntNew[i];
4825
4826 /* If the sibling page assembled above was not the right-most sibling,
4827 ** insert a divider cell into the parent page.
4828 */
drh14acc042001-06-10 19:56:58 +00004829 if( i<nNew-1 && j<nCell ){
drh8b18dd42004-05-12 19:18:15 +00004830 u8 *pCell;
drh24cd67e2004-05-10 16:18:47 +00004831 u8 *pTemp;
drh8b18dd42004-05-12 19:18:15 +00004832 int sz;
danielk1977634f2982005-03-28 08:44:07 +00004833
4834 assert( j<nMaxCells );
drh8b18dd42004-05-12 19:18:15 +00004835 pCell = apCell[j];
4836 sz = szCell[j] + leafCorrection;
drh4b70f112004-05-02 21:12:19 +00004837 if( !pNew->leaf ){
drh43605152004-05-29 21:46:49 +00004838 memcpy(&pNew->aData[8], pCell, 4);
drh24cd67e2004-05-10 16:18:47 +00004839 pTemp = 0;
drh8b18dd42004-05-12 19:18:15 +00004840 }else if( leafData ){
danielk1977ac11ee62005-01-15 12:45:51 +00004841 /* If the tree is a leaf-data tree, and the siblings are leaves,
4842 ** then there is no divider cell in apCell[]. Instead, the divider
4843 ** cell consists of the integer key for the right-most cell of
4844 ** the sibling-page assembled above only.
4845 */
drh6f11bef2004-05-13 01:12:56 +00004846 CellInfo info;
drh8b18dd42004-05-12 19:18:15 +00004847 j--;
drh43605152004-05-29 21:46:49 +00004848 parseCellPtr(pNew, apCell[j], &info);
drhb6f41482004-05-14 01:58:11 +00004849 pCell = &aSpace[iSpace];
drh6f11bef2004-05-13 01:12:56 +00004850 fillInCell(pParent, pCell, 0, info.nKey, 0, 0, &sz);
drhb6f41482004-05-14 01:58:11 +00004851 iSpace += sz;
drh07d183d2005-05-01 22:52:42 +00004852 assert( iSpace<=pBt->pageSize*5 );
drh8b18dd42004-05-12 19:18:15 +00004853 pTemp = 0;
drh4b70f112004-05-02 21:12:19 +00004854 }else{
4855 pCell -= 4;
drhb6f41482004-05-14 01:58:11 +00004856 pTemp = &aSpace[iSpace];
4857 iSpace += sz;
drh07d183d2005-05-01 22:52:42 +00004858 assert( iSpace<=pBt->pageSize*5 );
drh4b70f112004-05-02 21:12:19 +00004859 }
danielk1977a3ad5e72005-01-07 08:56:44 +00004860 rc = insertCell(pParent, nxDiv, pCell, sz, pTemp, 4);
danielk1977e80463b2004-11-03 03:01:16 +00004861 if( rc!=SQLITE_OK ) goto balance_cleanup;
drh43605152004-05-29 21:46:49 +00004862 put4byte(findOverflowCell(pParent,nxDiv), pNew->pgno);
danielk1977ac11ee62005-01-15 12:45:51 +00004863#ifndef SQLITE_OMIT_AUTOVACUUM
4864 /* If this is an auto-vacuum database, and not a leaf-data tree,
4865 ** then update the pointer map with an entry for the overflow page
4866 ** that the cell just inserted points to (if any).
4867 */
4868 if( pBt->autoVacuum && !leafData ){
danielk197779a40da2005-01-16 08:00:01 +00004869 rc = ptrmapPutOvfl(pParent, nxDiv);
4870 if( rc!=SQLITE_OK ){
4871 goto balance_cleanup;
danielk1977ac11ee62005-01-15 12:45:51 +00004872 }
4873 }
4874#endif
drh14acc042001-06-10 19:56:58 +00004875 j++;
4876 nxDiv++;
4877 }
4878 }
drh6019e162001-07-02 17:51:45 +00004879 assert( j==nCell );
drh7aa8f852006-03-28 00:24:44 +00004880 assert( nOld>0 );
4881 assert( nNew>0 );
drh4b70f112004-05-02 21:12:19 +00004882 if( (pageFlags & PTF_LEAF)==0 ){
drh43605152004-05-29 21:46:49 +00004883 memcpy(&apNew[nNew-1]->aData[8], &apCopy[nOld-1]->aData[8], 4);
drh14acc042001-06-10 19:56:58 +00004884 }
drh43605152004-05-29 21:46:49 +00004885 if( nxDiv==pParent->nCell+pParent->nOverflow ){
drh4b70f112004-05-02 21:12:19 +00004886 /* Right-most sibling is the right-most child of pParent */
drh43605152004-05-29 21:46:49 +00004887 put4byte(&pParent->aData[pParent->hdrOffset+8], pgnoNew[nNew-1]);
drh4b70f112004-05-02 21:12:19 +00004888 }else{
4889 /* Right-most sibling is the left child of the first entry in pParent
4890 ** past the right-most divider entry */
drh43605152004-05-29 21:46:49 +00004891 put4byte(findOverflowCell(pParent, nxDiv), pgnoNew[nNew-1]);
drh14acc042001-06-10 19:56:58 +00004892 }
4893
4894 /*
4895 ** Reparent children of all cells.
drh8b2f49b2001-06-08 00:21:52 +00004896 */
4897 for(i=0; i<nNew; i++){
danielk1977afcdd022004-10-31 16:25:42 +00004898 rc = reparentChildPages(apNew[i]);
4899 if( rc!=SQLITE_OK ) goto balance_cleanup;
drh8b2f49b2001-06-08 00:21:52 +00004900 }
danielk1977afcdd022004-10-31 16:25:42 +00004901 rc = reparentChildPages(pParent);
4902 if( rc!=SQLITE_OK ) goto balance_cleanup;
drh8b2f49b2001-06-08 00:21:52 +00004903
4904 /*
drh3a4c1412004-05-09 20:40:11 +00004905 ** Balance the parent page. Note that the current page (pPage) might
danielk1977ac11ee62005-01-15 12:45:51 +00004906 ** have been added to the freelist so it might no longer be initialized.
drh3a4c1412004-05-09 20:40:11 +00004907 ** But the parent page will always be initialized.
drh8b2f49b2001-06-08 00:21:52 +00004908 */
drhda200cc2004-05-09 11:51:38 +00004909 assert( pParent->isInit );
danielk1977ac245ec2005-01-14 13:50:11 +00004910 rc = balance(pParent, 0);
drhda200cc2004-05-09 11:51:38 +00004911
drh8b2f49b2001-06-08 00:21:52 +00004912 /*
drh14acc042001-06-10 19:56:58 +00004913 ** Cleanup before returning.
drh8b2f49b2001-06-08 00:21:52 +00004914 */
drh14acc042001-06-10 19:56:58 +00004915balance_cleanup:
drh2e38c322004-09-03 18:38:44 +00004916 sqliteFree(apCell);
drh8b2f49b2001-06-08 00:21:52 +00004917 for(i=0; i<nOld; i++){
drh91025292004-05-03 19:49:32 +00004918 releasePage(apOld[i]);
drh8b2f49b2001-06-08 00:21:52 +00004919 }
drh14acc042001-06-10 19:56:58 +00004920 for(i=0; i<nNew; i++){
drh91025292004-05-03 19:49:32 +00004921 releasePage(apNew[i]);
drh8b2f49b2001-06-08 00:21:52 +00004922 }
drh91025292004-05-03 19:49:32 +00004923 releasePage(pParent);
drh3a4c1412004-05-09 20:40:11 +00004924 TRACE(("BALANCE: finished with %d: old=%d new=%d cells=%d\n",
4925 pPage->pgno, nOld, nNew, nCell));
drh8b2f49b2001-06-08 00:21:52 +00004926 return rc;
4927}
4928
4929/*
drh43605152004-05-29 21:46:49 +00004930** This routine is called for the root page of a btree when the root
4931** page contains no cells. This is an opportunity to make the tree
4932** shallower by one level.
4933*/
4934static int balance_shallower(MemPage *pPage){
4935 MemPage *pChild; /* The only child page of pPage */
4936 Pgno pgnoChild; /* Page number for pChild */
drh2e38c322004-09-03 18:38:44 +00004937 int rc = SQLITE_OK; /* Return code from subprocedures */
danielk1977aef0bf62005-12-30 16:28:01 +00004938 BtShared *pBt; /* The main BTree structure */
drh2e38c322004-09-03 18:38:44 +00004939 int mxCellPerPage; /* Maximum number of cells per page */
4940 u8 **apCell; /* All cells from pages being balanced */
4941 int *szCell; /* Local size of all cells */
drh43605152004-05-29 21:46:49 +00004942
4943 assert( pPage->pParent==0 );
4944 assert( pPage->nCell==0 );
drh2e38c322004-09-03 18:38:44 +00004945 pBt = pPage->pBt;
4946 mxCellPerPage = MX_CELL(pBt);
4947 apCell = sqliteMallocRaw( mxCellPerPage*(sizeof(u8*)+sizeof(int)) );
4948 if( apCell==0 ) return SQLITE_NOMEM;
4949 szCell = (int*)&apCell[mxCellPerPage];
drh43605152004-05-29 21:46:49 +00004950 if( pPage->leaf ){
4951 /* The table is completely empty */
4952 TRACE(("BALANCE: empty table %d\n", pPage->pgno));
4953 }else{
4954 /* The root page is empty but has one child. Transfer the
4955 ** information from that one child into the root page if it
4956 ** will fit. This reduces the depth of the tree by one.
4957 **
4958 ** If the root page is page 1, it has less space available than
4959 ** its child (due to the 100 byte header that occurs at the beginning
4960 ** of the database fle), so it might not be able to hold all of the
4961 ** information currently contained in the child. If this is the
4962 ** case, then do not do the transfer. Leave page 1 empty except
4963 ** for the right-pointer to the child page. The child page becomes
4964 ** the virtual root of the tree.
4965 */
4966 pgnoChild = get4byte(&pPage->aData[pPage->hdrOffset+8]);
4967 assert( pgnoChild>0 );
4968 assert( pgnoChild<=sqlite3pager_pagecount(pPage->pBt->pPager) );
4969 rc = getPage(pPage->pBt, pgnoChild, &pChild);
drh2e38c322004-09-03 18:38:44 +00004970 if( rc ) goto end_shallow_balance;
drh43605152004-05-29 21:46:49 +00004971 if( pPage->pgno==1 ){
4972 rc = initPage(pChild, pPage);
drh2e38c322004-09-03 18:38:44 +00004973 if( rc ) goto end_shallow_balance;
drh43605152004-05-29 21:46:49 +00004974 assert( pChild->nOverflow==0 );
4975 if( pChild->nFree>=100 ){
4976 /* The child information will fit on the root page, so do the
4977 ** copy */
4978 int i;
4979 zeroPage(pPage, pChild->aData[0]);
4980 for(i=0; i<pChild->nCell; i++){
4981 apCell[i] = findCell(pChild,i);
4982 szCell[i] = cellSizePtr(pChild, apCell[i]);
4983 }
4984 assemblePage(pPage, pChild->nCell, apCell, szCell);
danielk1977ae825582004-11-23 09:06:55 +00004985 /* Copy the right-pointer of the child to the parent. */
4986 put4byte(&pPage->aData[pPage->hdrOffset+8],
4987 get4byte(&pChild->aData[pChild->hdrOffset+8]));
drh43605152004-05-29 21:46:49 +00004988 freePage(pChild);
4989 TRACE(("BALANCE: child %d transfer to page 1\n", pChild->pgno));
4990 }else{
4991 /* The child has more information that will fit on the root.
4992 ** The tree is already balanced. Do nothing. */
4993 TRACE(("BALANCE: child %d will not fit on page 1\n", pChild->pgno));
4994 }
4995 }else{
4996 memcpy(pPage->aData, pChild->aData, pPage->pBt->usableSize);
4997 pPage->isInit = 0;
4998 pPage->pParent = 0;
4999 rc = initPage(pPage, 0);
5000 assert( rc==SQLITE_OK );
5001 freePage(pChild);
5002 TRACE(("BALANCE: transfer child %d into root %d\n",
5003 pChild->pgno, pPage->pgno));
5004 }
danielk1977afcdd022004-10-31 16:25:42 +00005005 rc = reparentChildPages(pPage);
danielk1977ac11ee62005-01-15 12:45:51 +00005006 assert( pPage->nOverflow==0 );
5007#ifndef SQLITE_OMIT_AUTOVACUUM
5008 if( pBt->autoVacuum ){
danielk1977aac0a382005-01-16 11:07:06 +00005009 int i;
danielk1977ac11ee62005-01-15 12:45:51 +00005010 for(i=0; i<pPage->nCell; i++){
danielk197779a40da2005-01-16 08:00:01 +00005011 rc = ptrmapPutOvfl(pPage, i);
5012 if( rc!=SQLITE_OK ){
5013 goto end_shallow_balance;
danielk1977ac11ee62005-01-15 12:45:51 +00005014 }
5015 }
5016 }
5017#endif
danielk1977afcdd022004-10-31 16:25:42 +00005018 if( rc!=SQLITE_OK ) goto end_shallow_balance;
drh43605152004-05-29 21:46:49 +00005019 releasePage(pChild);
5020 }
drh2e38c322004-09-03 18:38:44 +00005021end_shallow_balance:
5022 sqliteFree(apCell);
5023 return rc;
drh43605152004-05-29 21:46:49 +00005024}
5025
5026
5027/*
5028** The root page is overfull
5029**
5030** When this happens, Create a new child page and copy the
5031** contents of the root into the child. Then make the root
5032** page an empty page with rightChild pointing to the new
5033** child. Finally, call balance_internal() on the new child
5034** to cause it to split.
5035*/
5036static int balance_deeper(MemPage *pPage){
5037 int rc; /* Return value from subprocedures */
5038 MemPage *pChild; /* Pointer to a new child page */
5039 Pgno pgnoChild; /* Page number of the new child page */
danielk1977aef0bf62005-12-30 16:28:01 +00005040 BtShared *pBt; /* The BTree */
drh43605152004-05-29 21:46:49 +00005041 int usableSize; /* Total usable size of a page */
5042 u8 *data; /* Content of the parent page */
5043 u8 *cdata; /* Content of the child page */
5044 int hdr; /* Offset to page header in parent */
5045 int brk; /* Offset to content of first cell in parent */
5046
5047 assert( pPage->pParent==0 );
5048 assert( pPage->nOverflow>0 );
5049 pBt = pPage->pBt;
danielk1977cb1a7eb2004-11-05 12:27:02 +00005050 rc = allocatePage(pBt, &pChild, &pgnoChild, pPage->pgno, 0);
drh43605152004-05-29 21:46:49 +00005051 if( rc ) return rc;
5052 assert( sqlite3pager_iswriteable(pChild->aData) );
5053 usableSize = pBt->usableSize;
5054 data = pPage->aData;
5055 hdr = pPage->hdrOffset;
5056 brk = get2byte(&data[hdr+5]);
5057 cdata = pChild->aData;
5058 memcpy(cdata, &data[hdr], pPage->cellOffset+2*pPage->nCell-hdr);
5059 memcpy(&cdata[brk], &data[brk], usableSize-brk);
danielk1977c7dc7532004-11-17 10:22:03 +00005060 assert( pChild->isInit==0 );
drh43605152004-05-29 21:46:49 +00005061 rc = initPage(pChild, pPage);
danielk19776b456a22005-03-21 04:04:02 +00005062 if( rc ) goto balancedeeper_out;
drh43605152004-05-29 21:46:49 +00005063 memcpy(pChild->aOvfl, pPage->aOvfl, pPage->nOverflow*sizeof(pPage->aOvfl[0]));
5064 pChild->nOverflow = pPage->nOverflow;
5065 if( pChild->nOverflow ){
5066 pChild->nFree = 0;
5067 }
5068 assert( pChild->nCell==pPage->nCell );
5069 zeroPage(pPage, pChild->aData[0] & ~PTF_LEAF);
5070 put4byte(&pPage->aData[pPage->hdrOffset+8], pgnoChild);
5071 TRACE(("BALANCE: copy root %d into %d\n", pPage->pgno, pChild->pgno));
danielk19774e17d142005-01-16 09:06:33 +00005072#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977ac11ee62005-01-15 12:45:51 +00005073 if( pBt->autoVacuum ){
5074 int i;
5075 rc = ptrmapPut(pBt, pChild->pgno, PTRMAP_BTREE, pPage->pgno);
danielk19776b456a22005-03-21 04:04:02 +00005076 if( rc ) goto balancedeeper_out;
danielk1977ac11ee62005-01-15 12:45:51 +00005077 for(i=0; i<pChild->nCell; i++){
danielk197779a40da2005-01-16 08:00:01 +00005078 rc = ptrmapPutOvfl(pChild, i);
5079 if( rc!=SQLITE_OK ){
5080 return rc;
danielk1977ac11ee62005-01-15 12:45:51 +00005081 }
5082 }
5083 }
danielk19774e17d142005-01-16 09:06:33 +00005084#endif
drh43605152004-05-29 21:46:49 +00005085 rc = balance_nonroot(pChild);
danielk19776b456a22005-03-21 04:04:02 +00005086
5087balancedeeper_out:
drh43605152004-05-29 21:46:49 +00005088 releasePage(pChild);
5089 return rc;
5090}
5091
5092/*
5093** Decide if the page pPage needs to be balanced. If balancing is
5094** required, call the appropriate balancing routine.
5095*/
danielk1977ac245ec2005-01-14 13:50:11 +00005096static int balance(MemPage *pPage, int insert){
drh43605152004-05-29 21:46:49 +00005097 int rc = SQLITE_OK;
5098 if( pPage->pParent==0 ){
5099 if( pPage->nOverflow>0 ){
5100 rc = balance_deeper(pPage);
5101 }
danielk1977687566d2004-11-02 12:56:41 +00005102 if( rc==SQLITE_OK && pPage->nCell==0 ){
drh43605152004-05-29 21:46:49 +00005103 rc = balance_shallower(pPage);
5104 }
5105 }else{
danielk1977ac245ec2005-01-14 13:50:11 +00005106 if( pPage->nOverflow>0 ||
5107 (!insert && pPage->nFree>pPage->pBt->usableSize*2/3) ){
drh43605152004-05-29 21:46:49 +00005108 rc = balance_nonroot(pPage);
5109 }
5110 }
5111 return rc;
5112}
5113
5114/*
drh8dcd7ca2004-08-08 19:43:29 +00005115** This routine checks all cursors that point to table pgnoRoot.
drh980b1a72006-08-16 16:42:48 +00005116** If any of those cursors were opened with wrFlag==0 in a different
5117** database connection (a database connection that shares the pager
5118** cache with the current connection) and that other connection
5119** is not in the ReadUncommmitted state, then this routine returns
5120** SQLITE_LOCKED.
danielk1977299b1872004-11-22 10:02:10 +00005121**
5122** In addition to checking for read-locks (where a read-lock
5123** means a cursor opened with wrFlag==0) this routine also moves
drh980b1a72006-08-16 16:42:48 +00005124** all cursors write cursors so that they are pointing to the
5125** first Cell on the root page. This is necessary because an insert
danielk1977299b1872004-11-22 10:02:10 +00005126** or delete might change the number of cells on a page or delete
5127** a page entirely and we do not want to leave any cursors
5128** pointing to non-existant pages or cells.
drhf74b8d92002-09-01 23:20:45 +00005129*/
drh980b1a72006-08-16 16:42:48 +00005130static int checkReadLocks(Btree *pBtree, Pgno pgnoRoot, BtCursor *pExclude){
danielk1977299b1872004-11-22 10:02:10 +00005131 BtCursor *p;
drh980b1a72006-08-16 16:42:48 +00005132 BtShared *pBt = pBtree->pBt;
5133 sqlite3 *db = pBtree->pSqlite;
danielk1977299b1872004-11-22 10:02:10 +00005134 for(p=pBt->pCursor; p; p=p->pNext){
drh980b1a72006-08-16 16:42:48 +00005135 if( p==pExclude ) continue;
5136 if( p->eState!=CURSOR_VALID ) continue;
5137 if( p->pgnoRoot!=pgnoRoot ) continue;
5138 if( p->wrFlag==0 ){
5139 sqlite3 *dbOther = p->pBtree->pSqlite;
5140 if( dbOther==0 ||
5141 (dbOther!=db && (dbOther->flags & SQLITE_ReadUncommitted)==0) ){
5142 return SQLITE_LOCKED;
5143 }
5144 }else if( p->pPage->pgno!=p->pgnoRoot ){
danielk1977299b1872004-11-22 10:02:10 +00005145 moveToRoot(p);
5146 }
5147 }
drhf74b8d92002-09-01 23:20:45 +00005148 return SQLITE_OK;
5149}
5150
5151/*
drh3b7511c2001-05-26 13:15:44 +00005152** Insert a new record into the BTree. The key is given by (pKey,nKey)
5153** and the data is given by (pData,nData). The cursor is used only to
drh91025292004-05-03 19:49:32 +00005154** define what table the record should be inserted into. The cursor
drh4b70f112004-05-02 21:12:19 +00005155** is left pointing at a random location.
5156**
5157** For an INTKEY table, only the nKey value of the key is used. pKey is
5158** ignored. For a ZERODATA table, the pData and nData are both ignored.
drh3b7511c2001-05-26 13:15:44 +00005159*/
drh3aac2dd2004-04-26 14:10:20 +00005160int sqlite3BtreeInsert(
drh5c4d9702001-08-20 00:33:58 +00005161 BtCursor *pCur, /* Insert data into the table of this cursor */
drh4a1c3802004-05-12 15:15:47 +00005162 const void *pKey, i64 nKey, /* The key of the new record */
drh5c4d9702001-08-20 00:33:58 +00005163 const void *pData, int nData /* The data of the new record */
drh3b7511c2001-05-26 13:15:44 +00005164){
drh3b7511c2001-05-26 13:15:44 +00005165 int rc;
5166 int loc;
drh14acc042001-06-10 19:56:58 +00005167 int szNew;
drh3b7511c2001-05-26 13:15:44 +00005168 MemPage *pPage;
danielk1977aef0bf62005-12-30 16:28:01 +00005169 BtShared *pBt = pCur->pBtree->pBt;
drha34b6762004-05-07 13:30:42 +00005170 unsigned char *oldCell;
drh2e38c322004-09-03 18:38:44 +00005171 unsigned char *newCell = 0;
drh3b7511c2001-05-26 13:15:44 +00005172
danielk1977aef0bf62005-12-30 16:28:01 +00005173 if( pBt->inTransaction!=TRANS_WRITE ){
drhf74b8d92002-09-01 23:20:45 +00005174 /* Must start a transaction before doing an insert */
5175 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh8b2f49b2001-06-08 00:21:52 +00005176 }
drhf74b8d92002-09-01 23:20:45 +00005177 assert( !pBt->readOnly );
drhecdc7532001-09-23 02:35:53 +00005178 if( !pCur->wrFlag ){
5179 return SQLITE_PERM; /* Cursor not open for writing */
5180 }
drh980b1a72006-08-16 16:42:48 +00005181 if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur) ){
drhf74b8d92002-09-01 23:20:45 +00005182 return SQLITE_LOCKED; /* The table pCur points to has a read lock */
5183 }
danielk1977da184232006-01-05 11:34:32 +00005184
5185 /* Save the positions of any other cursors open on this table */
drh777e4c42006-01-13 04:31:58 +00005186 restoreOrClearCursorPosition(pCur, 0);
danielk19772e94d4d2006-01-09 05:36:27 +00005187 if(
danielk19772e94d4d2006-01-09 05:36:27 +00005188 SQLITE_OK!=(rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur)) ||
5189 SQLITE_OK!=(rc = sqlite3BtreeMoveto(pCur, pKey, nKey, &loc))
5190 ){
danielk1977da184232006-01-05 11:34:32 +00005191 return rc;
5192 }
5193
drh14acc042001-06-10 19:56:58 +00005194 pPage = pCur->pPage;
drh4a1c3802004-05-12 15:15:47 +00005195 assert( pPage->intKey || nKey>=0 );
drh8b18dd42004-05-12 19:18:15 +00005196 assert( pPage->leaf || !pPage->leafData );
drh3a4c1412004-05-09 20:40:11 +00005197 TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
5198 pCur->pgnoRoot, nKey, nData, pPage->pgno,
5199 loc==0 ? "overwrite" : "new entry"));
drh7aa128d2002-06-21 13:09:16 +00005200 assert( pPage->isInit );
drha34b6762004-05-07 13:30:42 +00005201 rc = sqlite3pager_write(pPage->aData);
drhbd03cae2001-06-02 02:40:57 +00005202 if( rc ) return rc;
drh2e38c322004-09-03 18:38:44 +00005203 newCell = sqliteMallocRaw( MX_CELL_SIZE(pBt) );
5204 if( newCell==0 ) return SQLITE_NOMEM;
drha34b6762004-05-07 13:30:42 +00005205 rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, &szNew);
drh2e38c322004-09-03 18:38:44 +00005206 if( rc ) goto end_insert;
drh43605152004-05-29 21:46:49 +00005207 assert( szNew==cellSizePtr(pPage, newCell) );
drh2e38c322004-09-03 18:38:44 +00005208 assert( szNew<=MX_CELL_SIZE(pBt) );
danielk1977da184232006-01-05 11:34:32 +00005209 if( loc==0 && CURSOR_VALID==pCur->eState ){
drha34b6762004-05-07 13:30:42 +00005210 int szOld;
5211 assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
drh43605152004-05-29 21:46:49 +00005212 oldCell = findCell(pPage, pCur->idx);
drh4b70f112004-05-02 21:12:19 +00005213 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00005214 memcpy(newCell, oldCell, 4);
drh4b70f112004-05-02 21:12:19 +00005215 }
drh43605152004-05-29 21:46:49 +00005216 szOld = cellSizePtr(pPage, oldCell);
drh4b70f112004-05-02 21:12:19 +00005217 rc = clearCell(pPage, oldCell);
drh2e38c322004-09-03 18:38:44 +00005218 if( rc ) goto end_insert;
drh4b70f112004-05-02 21:12:19 +00005219 dropCell(pPage, pCur->idx, szOld);
drh7c717f72001-06-24 20:39:41 +00005220 }else if( loc<0 && pPage->nCell>0 ){
drh4b70f112004-05-02 21:12:19 +00005221 assert( pPage->leaf );
drh14acc042001-06-10 19:56:58 +00005222 pCur->idx++;
drh271efa52004-05-30 19:19:05 +00005223 pCur->info.nSize = 0;
drh14acc042001-06-10 19:56:58 +00005224 }else{
drh4b70f112004-05-02 21:12:19 +00005225 assert( pPage->leaf );
drh3b7511c2001-05-26 13:15:44 +00005226 }
danielk1977a3ad5e72005-01-07 08:56:44 +00005227 rc = insertCell(pPage, pCur->idx, newCell, szNew, 0, 0);
danielk1977e80463b2004-11-03 03:01:16 +00005228 if( rc!=SQLITE_OK ) goto end_insert;
danielk1977ac245ec2005-01-14 13:50:11 +00005229 rc = balance(pPage, 1);
drh23e11ca2004-05-04 17:27:28 +00005230 /* sqlite3BtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */
drh3fc190c2001-09-14 03:24:23 +00005231 /* fflush(stdout); */
danielk1977299b1872004-11-22 10:02:10 +00005232 if( rc==SQLITE_OK ){
5233 moveToRoot(pCur);
5234 }
drh2e38c322004-09-03 18:38:44 +00005235end_insert:
5236 sqliteFree(newCell);
drh5e2f8b92001-05-28 00:41:15 +00005237 return rc;
5238}
5239
5240/*
drh4b70f112004-05-02 21:12:19 +00005241** Delete the entry that the cursor is pointing to. The cursor
5242** is left pointing at a random location.
drh3b7511c2001-05-26 13:15:44 +00005243*/
drh3aac2dd2004-04-26 14:10:20 +00005244int sqlite3BtreeDelete(BtCursor *pCur){
drh5e2f8b92001-05-28 00:41:15 +00005245 MemPage *pPage = pCur->pPage;
drh4b70f112004-05-02 21:12:19 +00005246 unsigned char *pCell;
drh5e2f8b92001-05-28 00:41:15 +00005247 int rc;
danielk1977cfe9a692004-06-16 12:00:29 +00005248 Pgno pgnoChild = 0;
danielk1977aef0bf62005-12-30 16:28:01 +00005249 BtShared *pBt = pCur->pBtree->pBt;
drh8b2f49b2001-06-08 00:21:52 +00005250
drh7aa128d2002-06-21 13:09:16 +00005251 assert( pPage->isInit );
danielk1977aef0bf62005-12-30 16:28:01 +00005252 if( pBt->inTransaction!=TRANS_WRITE ){
drhf74b8d92002-09-01 23:20:45 +00005253 /* Must start a transaction before doing a delete */
5254 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh8b2f49b2001-06-08 00:21:52 +00005255 }
drhf74b8d92002-09-01 23:20:45 +00005256 assert( !pBt->readOnly );
drhbd03cae2001-06-02 02:40:57 +00005257 if( pCur->idx >= pPage->nCell ){
5258 return SQLITE_ERROR; /* The cursor is not pointing to anything */
5259 }
drhecdc7532001-09-23 02:35:53 +00005260 if( !pCur->wrFlag ){
5261 return SQLITE_PERM; /* Did not open this cursor for writing */
5262 }
drh980b1a72006-08-16 16:42:48 +00005263 if( checkReadLocks(pCur->pBtree, pCur->pgnoRoot, pCur) ){
drhf74b8d92002-09-01 23:20:45 +00005264 return SQLITE_LOCKED; /* The table pCur points to has a read lock */
5265 }
danielk1977da184232006-01-05 11:34:32 +00005266
5267 /* Restore the current cursor position (a no-op if the cursor is not in
5268 ** CURSOR_REQUIRESEEK state) and save the positions of any other cursors
5269 ** open on the same table. Then call sqlite3pager_write() on the page
5270 ** that the entry will be deleted from.
5271 */
5272 if(
drhd1167392006-01-23 13:00:35 +00005273 (rc = restoreOrClearCursorPosition(pCur, 1))!=0 ||
5274 (rc = saveAllCursors(pBt, pCur->pgnoRoot, pCur))!=0 ||
5275 (rc = sqlite3pager_write(pPage->aData))!=0
danielk1977da184232006-01-05 11:34:32 +00005276 ){
5277 return rc;
5278 }
danielk1977e6efa742004-11-10 11:55:10 +00005279
5280 /* Locate the cell within it's page and leave pCell pointing to the
5281 ** data. The clearCell() call frees any overflow pages associated with the
5282 ** cell. The cell itself is still intact.
5283 */
danielk1977299b1872004-11-22 10:02:10 +00005284 pCell = findCell(pPage, pCur->idx);
drh4b70f112004-05-02 21:12:19 +00005285 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00005286 pgnoChild = get4byte(pCell);
drh4b70f112004-05-02 21:12:19 +00005287 }
danielk197728129562005-01-11 10:25:06 +00005288 rc = clearCell(pPage, pCell);
5289 if( rc ) return rc;
danielk1977e6efa742004-11-10 11:55:10 +00005290
drh4b70f112004-05-02 21:12:19 +00005291 if( !pPage->leaf ){
drh14acc042001-06-10 19:56:58 +00005292 /*
drh5e00f6c2001-09-13 13:46:56 +00005293 ** The entry we are about to delete is not a leaf so if we do not
drh9ca7d3b2001-06-28 11:50:21 +00005294 ** do something we will leave a hole on an internal page.
5295 ** We have to fill the hole by moving in a cell from a leaf. The
5296 ** next Cell after the one to be deleted is guaranteed to exist and
danielk1977299b1872004-11-22 10:02:10 +00005297 ** to be a leaf so we can use it.
drh5e2f8b92001-05-28 00:41:15 +00005298 */
drh14acc042001-06-10 19:56:58 +00005299 BtCursor leafCur;
drh4b70f112004-05-02 21:12:19 +00005300 unsigned char *pNext;
drh02afc862006-01-20 18:10:57 +00005301 int szNext; /* The compiler warning is wrong: szNext is always
5302 ** initialized before use. Adding an extra initialization
5303 ** to silence the compiler slows down the code. */
danielk1977299b1872004-11-22 10:02:10 +00005304 int notUsed;
danielk19776b456a22005-03-21 04:04:02 +00005305 unsigned char *tempCell = 0;
drh8b18dd42004-05-12 19:18:15 +00005306 assert( !pPage->leafData );
drh14acc042001-06-10 19:56:58 +00005307 getTempCursor(pCur, &leafCur);
danielk1977299b1872004-11-22 10:02:10 +00005308 rc = sqlite3BtreeNext(&leafCur, &notUsed);
drh14acc042001-06-10 19:56:58 +00005309 if( rc!=SQLITE_OK ){
drhee696e22004-08-30 16:52:17 +00005310 if( rc!=SQLITE_NOMEM ){
drh49285702005-09-17 15:20:26 +00005311 rc = SQLITE_CORRUPT_BKPT;
drhee696e22004-08-30 16:52:17 +00005312 }
drh5e2f8b92001-05-28 00:41:15 +00005313 }
danielk19776b456a22005-03-21 04:04:02 +00005314 if( rc==SQLITE_OK ){
5315 rc = sqlite3pager_write(leafCur.pPage->aData);
5316 }
5317 if( rc==SQLITE_OK ){
5318 TRACE(("DELETE: table=%d delete internal from %d replace from leaf %d\n",
5319 pCur->pgnoRoot, pPage->pgno, leafCur.pPage->pgno));
5320 dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell));
5321 pNext = findCell(leafCur.pPage, leafCur.idx);
5322 szNext = cellSizePtr(leafCur.pPage, pNext);
5323 assert( MX_CELL_SIZE(pBt)>=szNext+4 );
5324 tempCell = sqliteMallocRaw( MX_CELL_SIZE(pBt) );
5325 if( tempCell==0 ){
5326 rc = SQLITE_NOMEM;
5327 }
5328 }
5329 if( rc==SQLITE_OK ){
5330 rc = insertCell(pPage, pCur->idx, pNext-4, szNext+4, tempCell, 0);
5331 }
5332 if( rc==SQLITE_OK ){
5333 put4byte(findOverflowCell(pPage, pCur->idx), pgnoChild);
5334 rc = balance(pPage, 0);
5335 }
5336 if( rc==SQLITE_OK ){
5337 dropCell(leafCur.pPage, leafCur.idx, szNext);
5338 rc = balance(leafCur.pPage, 0);
5339 }
drh2e38c322004-09-03 18:38:44 +00005340 sqliteFree(tempCell);
drh8c42ca92001-06-22 19:15:00 +00005341 releaseTempCursor(&leafCur);
drh5e2f8b92001-05-28 00:41:15 +00005342 }else{
danielk1977299b1872004-11-22 10:02:10 +00005343 TRACE(("DELETE: table=%d delete from leaf %d\n",
5344 pCur->pgnoRoot, pPage->pgno));
5345 dropCell(pPage, pCur->idx, cellSizePtr(pPage, pCell));
danielk1977ac245ec2005-01-14 13:50:11 +00005346 rc = balance(pPage, 0);
drh5e2f8b92001-05-28 00:41:15 +00005347 }
danielk19776b456a22005-03-21 04:04:02 +00005348 if( rc==SQLITE_OK ){
5349 moveToRoot(pCur);
5350 }
drh5e2f8b92001-05-28 00:41:15 +00005351 return rc;
drh3b7511c2001-05-26 13:15:44 +00005352}
drh8b2f49b2001-06-08 00:21:52 +00005353
5354/*
drhc6b52df2002-01-04 03:09:29 +00005355** Create a new BTree table. Write into *piTable the page
5356** number for the root page of the new table.
5357**
drhab01f612004-05-22 02:55:23 +00005358** The type of type is determined by the flags parameter. Only the
5359** following values of flags are currently in use. Other values for
5360** flags might not work:
5361**
5362** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys
5363** BTREE_ZERODATA Used for SQL indices
drh8b2f49b2001-06-08 00:21:52 +00005364*/
danielk1977aef0bf62005-12-30 16:28:01 +00005365int sqlite3BtreeCreateTable(Btree *p, int *piTable, int flags){
5366 BtShared *pBt = p->pBt;
drh8b2f49b2001-06-08 00:21:52 +00005367 MemPage *pRoot;
5368 Pgno pgnoRoot;
5369 int rc;
danielk1977aef0bf62005-12-30 16:28:01 +00005370 if( pBt->inTransaction!=TRANS_WRITE ){
drhf74b8d92002-09-01 23:20:45 +00005371 /* Must start a transaction first */
5372 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh8b2f49b2001-06-08 00:21:52 +00005373 }
danielk197728129562005-01-11 10:25:06 +00005374 assert( !pBt->readOnly );
danielk1977e6efa742004-11-10 11:55:10 +00005375
5376 /* It is illegal to create a table if any cursors are open on the
5377 ** database. This is because in auto-vacuum mode the backend may
5378 ** need to move a database page to make room for the new root-page.
5379 ** If an open cursor was using the page a problem would occur.
5380 */
5381 if( pBt->pCursor ){
5382 return SQLITE_LOCKED;
5383 }
5384
danielk1977003ba062004-11-04 02:57:33 +00005385#ifdef SQLITE_OMIT_AUTOVACUUM
danielk1977cb1a7eb2004-11-05 12:27:02 +00005386 rc = allocatePage(pBt, &pRoot, &pgnoRoot, 1, 0);
drh8b2f49b2001-06-08 00:21:52 +00005387 if( rc ) return rc;
danielk1977003ba062004-11-04 02:57:33 +00005388#else
danielk1977687566d2004-11-02 12:56:41 +00005389 if( pBt->autoVacuum ){
danielk1977003ba062004-11-04 02:57:33 +00005390 Pgno pgnoMove; /* Move a page here to make room for the root-page */
5391 MemPage *pPageMove; /* The page to move to. */
5392
danielk1977003ba062004-11-04 02:57:33 +00005393 /* Read the value of meta[3] from the database to determine where the
5394 ** root page of the new table should go. meta[3] is the largest root-page
5395 ** created so far, so the new root-page is (meta[3]+1).
5396 */
danielk1977aef0bf62005-12-30 16:28:01 +00005397 rc = sqlite3BtreeGetMeta(p, 4, &pgnoRoot);
danielk1977003ba062004-11-04 02:57:33 +00005398 if( rc!=SQLITE_OK ) return rc;
5399 pgnoRoot++;
5400
danielk1977599fcba2004-11-08 07:13:13 +00005401 /* The new root-page may not be allocated on a pointer-map page, or the
5402 ** PENDING_BYTE page.
5403 */
danielk1977266664d2006-02-10 08:24:21 +00005404 if( pgnoRoot==PTRMAP_PAGENO(pBt, pgnoRoot) ||
danielk1977599fcba2004-11-08 07:13:13 +00005405 pgnoRoot==PENDING_BYTE_PAGE(pBt) ){
danielk1977003ba062004-11-04 02:57:33 +00005406 pgnoRoot++;
5407 }
5408 assert( pgnoRoot>=3 );
5409
5410 /* Allocate a page. The page that currently resides at pgnoRoot will
5411 ** be moved to the allocated page (unless the allocated page happens
5412 ** to reside at pgnoRoot).
5413 */
danielk1977cb1a7eb2004-11-05 12:27:02 +00005414 rc = allocatePage(pBt, &pPageMove, &pgnoMove, pgnoRoot, 1);
danielk1977003ba062004-11-04 02:57:33 +00005415 if( rc!=SQLITE_OK ){
danielk1977687566d2004-11-02 12:56:41 +00005416 return rc;
5417 }
danielk1977003ba062004-11-04 02:57:33 +00005418
5419 if( pgnoMove!=pgnoRoot ){
5420 u8 eType;
5421 Pgno iPtrPage;
5422
5423 releasePage(pPageMove);
5424 rc = getPage(pBt, pgnoRoot, &pRoot);
5425 if( rc!=SQLITE_OK ){
5426 return rc;
5427 }
5428 rc = ptrmapGet(pBt, pgnoRoot, &eType, &iPtrPage);
drhccae6022005-02-26 17:31:26 +00005429 if( rc!=SQLITE_OK || eType==PTRMAP_ROOTPAGE || eType==PTRMAP_FREEPAGE ){
danielk1977003ba062004-11-04 02:57:33 +00005430 releasePage(pRoot);
5431 return rc;
5432 }
drhccae6022005-02-26 17:31:26 +00005433 assert( eType!=PTRMAP_ROOTPAGE );
5434 assert( eType!=PTRMAP_FREEPAGE );
danielk19775fd057a2005-03-09 13:09:43 +00005435 rc = sqlite3pager_write(pRoot->aData);
5436 if( rc!=SQLITE_OK ){
5437 releasePage(pRoot);
5438 return rc;
5439 }
danielk1977003ba062004-11-04 02:57:33 +00005440 rc = relocatePage(pBt, pRoot, eType, iPtrPage, pgnoMove);
5441 releasePage(pRoot);
5442 if( rc!=SQLITE_OK ){
5443 return rc;
5444 }
5445 rc = getPage(pBt, pgnoRoot, &pRoot);
5446 if( rc!=SQLITE_OK ){
5447 return rc;
5448 }
5449 rc = sqlite3pager_write(pRoot->aData);
5450 if( rc!=SQLITE_OK ){
5451 releasePage(pRoot);
5452 return rc;
5453 }
5454 }else{
5455 pRoot = pPageMove;
5456 }
5457
danielk197742741be2005-01-08 12:42:39 +00005458 /* Update the pointer-map and meta-data with the new root-page number. */
danielk1977003ba062004-11-04 02:57:33 +00005459 rc = ptrmapPut(pBt, pgnoRoot, PTRMAP_ROOTPAGE, 0);
5460 if( rc ){
5461 releasePage(pRoot);
5462 return rc;
5463 }
danielk1977aef0bf62005-12-30 16:28:01 +00005464 rc = sqlite3BtreeUpdateMeta(p, 4, pgnoRoot);
danielk1977003ba062004-11-04 02:57:33 +00005465 if( rc ){
5466 releasePage(pRoot);
5467 return rc;
5468 }
danielk197742741be2005-01-08 12:42:39 +00005469
danielk1977003ba062004-11-04 02:57:33 +00005470 }else{
danielk1977cb1a7eb2004-11-05 12:27:02 +00005471 rc = allocatePage(pBt, &pRoot, &pgnoRoot, 1, 0);
danielk1977003ba062004-11-04 02:57:33 +00005472 if( rc ) return rc;
danielk1977687566d2004-11-02 12:56:41 +00005473 }
5474#endif
drha34b6762004-05-07 13:30:42 +00005475 assert( sqlite3pager_iswriteable(pRoot->aData) );
drhde647132004-05-07 17:57:49 +00005476 zeroPage(pRoot, flags | PTF_LEAF);
drha34b6762004-05-07 13:30:42 +00005477 sqlite3pager_unref(pRoot->aData);
drh8b2f49b2001-06-08 00:21:52 +00005478 *piTable = (int)pgnoRoot;
5479 return SQLITE_OK;
5480}
5481
5482/*
5483** Erase the given database page and all its children. Return
5484** the page to the freelist.
5485*/
drh4b70f112004-05-02 21:12:19 +00005486static int clearDatabasePage(
danielk1977aef0bf62005-12-30 16:28:01 +00005487 BtShared *pBt, /* The BTree that contains the table */
drh4b70f112004-05-02 21:12:19 +00005488 Pgno pgno, /* Page number to clear */
5489 MemPage *pParent, /* Parent page. NULL for the root */
5490 int freePageFlag /* Deallocate page if true */
5491){
danielk19776b456a22005-03-21 04:04:02 +00005492 MemPage *pPage = 0;
drh8b2f49b2001-06-08 00:21:52 +00005493 int rc;
drh4b70f112004-05-02 21:12:19 +00005494 unsigned char *pCell;
5495 int i;
drh8b2f49b2001-06-08 00:21:52 +00005496
danielk1977a1cb1832005-02-12 08:59:55 +00005497 if( pgno>sqlite3pager_pagecount(pBt->pPager) ){
drh49285702005-09-17 15:20:26 +00005498 return SQLITE_CORRUPT_BKPT;
danielk1977a1cb1832005-02-12 08:59:55 +00005499 }
5500
drhde647132004-05-07 17:57:49 +00005501 rc = getAndInitPage(pBt, pgno, &pPage, pParent);
danielk19776b456a22005-03-21 04:04:02 +00005502 if( rc ) goto cleardatabasepage_out;
drha34b6762004-05-07 13:30:42 +00005503 rc = sqlite3pager_write(pPage->aData);
danielk19776b456a22005-03-21 04:04:02 +00005504 if( rc ) goto cleardatabasepage_out;
drh4b70f112004-05-02 21:12:19 +00005505 for(i=0; i<pPage->nCell; i++){
drh43605152004-05-29 21:46:49 +00005506 pCell = findCell(pPage, i);
drh4b70f112004-05-02 21:12:19 +00005507 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00005508 rc = clearDatabasePage(pBt, get4byte(pCell), pPage->pParent, 1);
danielk19776b456a22005-03-21 04:04:02 +00005509 if( rc ) goto cleardatabasepage_out;
drh8b2f49b2001-06-08 00:21:52 +00005510 }
drh4b70f112004-05-02 21:12:19 +00005511 rc = clearCell(pPage, pCell);
danielk19776b456a22005-03-21 04:04:02 +00005512 if( rc ) goto cleardatabasepage_out;
drh8b2f49b2001-06-08 00:21:52 +00005513 }
drha34b6762004-05-07 13:30:42 +00005514 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00005515 rc = clearDatabasePage(pBt, get4byte(&pPage->aData[8]), pPage->pParent, 1);
danielk19776b456a22005-03-21 04:04:02 +00005516 if( rc ) goto cleardatabasepage_out;
drh2aa679f2001-06-25 02:11:07 +00005517 }
5518 if( freePageFlag ){
drh4b70f112004-05-02 21:12:19 +00005519 rc = freePage(pPage);
drh2aa679f2001-06-25 02:11:07 +00005520 }else{
drh3a4c1412004-05-09 20:40:11 +00005521 zeroPage(pPage, pPage->aData[0] | PTF_LEAF);
drh2aa679f2001-06-25 02:11:07 +00005522 }
danielk19776b456a22005-03-21 04:04:02 +00005523
5524cleardatabasepage_out:
drh4b70f112004-05-02 21:12:19 +00005525 releasePage(pPage);
drh2aa679f2001-06-25 02:11:07 +00005526 return rc;
drh8b2f49b2001-06-08 00:21:52 +00005527}
5528
5529/*
drhab01f612004-05-22 02:55:23 +00005530** Delete all information from a single table in the database. iTable is
5531** the page number of the root of the table. After this routine returns,
5532** the root page is empty, but still exists.
5533**
5534** This routine will fail with SQLITE_LOCKED if there are any open
5535** read cursors on the table. Open write cursors are moved to the
5536** root of the table.
drh8b2f49b2001-06-08 00:21:52 +00005537*/
danielk1977aef0bf62005-12-30 16:28:01 +00005538int sqlite3BtreeClearTable(Btree *p, int iTable){
drh8b2f49b2001-06-08 00:21:52 +00005539 int rc;
danielk1977aef0bf62005-12-30 16:28:01 +00005540 BtShared *pBt = p->pBt;
5541 if( p->inTrans!=TRANS_WRITE ){
drhf74b8d92002-09-01 23:20:45 +00005542 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh8b2f49b2001-06-08 00:21:52 +00005543 }
drh980b1a72006-08-16 16:42:48 +00005544 rc = checkReadLocks(p, iTable, 0);
5545 if( rc ){
5546 return rc;
drhecdc7532001-09-23 02:35:53 +00005547 }
danielk1977ed429312006-01-19 08:43:31 +00005548
5549 /* Save the position of all cursors open on this table */
5550 if( SQLITE_OK!=(rc = saveAllCursors(pBt, iTable, 0)) ){
5551 return rc;
drh8b2f49b2001-06-08 00:21:52 +00005552 }
danielk1977ed429312006-01-19 08:43:31 +00005553
5554 return clearDatabasePage(pBt, (Pgno)iTable, 0, 0);
drh8b2f49b2001-06-08 00:21:52 +00005555}
5556
5557/*
5558** Erase all information in a table and add the root of the table to
5559** the freelist. Except, the root of the principle table (the one on
drhab01f612004-05-22 02:55:23 +00005560** page 1) is never added to the freelist.
5561**
5562** This routine will fail with SQLITE_LOCKED if there are any open
5563** cursors on the table.
drh205f48e2004-11-05 00:43:11 +00005564**
5565** If AUTOVACUUM is enabled and the page at iTable is not the last
5566** root page in the database file, then the last root page
5567** in the database file is moved into the slot formerly occupied by
5568** iTable and that last slot formerly occupied by the last root page
5569** is added to the freelist instead of iTable. In this say, all
5570** root pages are kept at the beginning of the database file, which
5571** is necessary for AUTOVACUUM to work right. *piMoved is set to the
5572** page number that used to be the last root page in the file before
5573** the move. If no page gets moved, *piMoved is set to 0.
5574** The last root page is recorded in meta[3] and the value of
5575** meta[3] is updated by this procedure.
drh8b2f49b2001-06-08 00:21:52 +00005576*/
danielk1977aef0bf62005-12-30 16:28:01 +00005577int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
drh8b2f49b2001-06-08 00:21:52 +00005578 int rc;
danielk1977a0bf2652004-11-04 14:30:04 +00005579 MemPage *pPage = 0;
danielk1977aef0bf62005-12-30 16:28:01 +00005580 BtShared *pBt = p->pBt;
danielk1977a0bf2652004-11-04 14:30:04 +00005581
danielk1977aef0bf62005-12-30 16:28:01 +00005582 if( p->inTrans!=TRANS_WRITE ){
drhf74b8d92002-09-01 23:20:45 +00005583 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh8b2f49b2001-06-08 00:21:52 +00005584 }
danielk1977a0bf2652004-11-04 14:30:04 +00005585
danielk1977e6efa742004-11-10 11:55:10 +00005586 /* It is illegal to drop a table if any cursors are open on the
5587 ** database. This is because in auto-vacuum mode the backend may
5588 ** need to move another root-page to fill a gap left by the deleted
5589 ** root page. If an open cursor was using this page a problem would
5590 ** occur.
5591 */
5592 if( pBt->pCursor ){
5593 return SQLITE_LOCKED;
drh5df72a52002-06-06 23:16:05 +00005594 }
danielk1977a0bf2652004-11-04 14:30:04 +00005595
drha34b6762004-05-07 13:30:42 +00005596 rc = getPage(pBt, (Pgno)iTable, &pPage);
drh2aa679f2001-06-25 02:11:07 +00005597 if( rc ) return rc;
danielk1977aef0bf62005-12-30 16:28:01 +00005598 rc = sqlite3BtreeClearTable(p, iTable);
danielk19776b456a22005-03-21 04:04:02 +00005599 if( rc ){
5600 releasePage(pPage);
5601 return rc;
5602 }
danielk1977a0bf2652004-11-04 14:30:04 +00005603
drh205f48e2004-11-05 00:43:11 +00005604 *piMoved = 0;
danielk1977a0bf2652004-11-04 14:30:04 +00005605
drh4b70f112004-05-02 21:12:19 +00005606 if( iTable>1 ){
danielk1977a0bf2652004-11-04 14:30:04 +00005607#ifdef SQLITE_OMIT_AUTOVACUUM
drha34b6762004-05-07 13:30:42 +00005608 rc = freePage(pPage);
danielk1977a0bf2652004-11-04 14:30:04 +00005609 releasePage(pPage);
5610#else
5611 if( pBt->autoVacuum ){
5612 Pgno maxRootPgno;
danielk1977aef0bf62005-12-30 16:28:01 +00005613 rc = sqlite3BtreeGetMeta(p, 4, &maxRootPgno);
danielk1977a0bf2652004-11-04 14:30:04 +00005614 if( rc!=SQLITE_OK ){
5615 releasePage(pPage);
5616 return rc;
5617 }
5618
5619 if( iTable==maxRootPgno ){
5620 /* If the table being dropped is the table with the largest root-page
5621 ** number in the database, put the root page on the free list.
5622 */
5623 rc = freePage(pPage);
5624 releasePage(pPage);
5625 if( rc!=SQLITE_OK ){
5626 return rc;
5627 }
5628 }else{
5629 /* The table being dropped does not have the largest root-page
5630 ** number in the database. So move the page that does into the
5631 ** gap left by the deleted root-page.
5632 */
5633 MemPage *pMove;
5634 releasePage(pPage);
5635 rc = getPage(pBt, maxRootPgno, &pMove);
5636 if( rc!=SQLITE_OK ){
5637 return rc;
5638 }
5639 rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable);
5640 releasePage(pMove);
5641 if( rc!=SQLITE_OK ){
5642 return rc;
5643 }
5644 rc = getPage(pBt, maxRootPgno, &pMove);
5645 if( rc!=SQLITE_OK ){
5646 return rc;
5647 }
5648 rc = freePage(pMove);
5649 releasePage(pMove);
5650 if( rc!=SQLITE_OK ){
5651 return rc;
5652 }
5653 *piMoved = maxRootPgno;
5654 }
5655
danielk1977599fcba2004-11-08 07:13:13 +00005656 /* Set the new 'max-root-page' value in the database header. This
5657 ** is the old value less one, less one more if that happens to
5658 ** be a root-page number, less one again if that is the
5659 ** PENDING_BYTE_PAGE.
5660 */
danielk197787a6e732004-11-05 12:58:25 +00005661 maxRootPgno--;
danielk1977599fcba2004-11-08 07:13:13 +00005662 if( maxRootPgno==PENDING_BYTE_PAGE(pBt) ){
5663 maxRootPgno--;
5664 }
danielk1977266664d2006-02-10 08:24:21 +00005665 if( maxRootPgno==PTRMAP_PAGENO(pBt, maxRootPgno) ){
danielk197787a6e732004-11-05 12:58:25 +00005666 maxRootPgno--;
5667 }
danielk1977599fcba2004-11-08 07:13:13 +00005668 assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
5669
danielk1977aef0bf62005-12-30 16:28:01 +00005670 rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
danielk1977a0bf2652004-11-04 14:30:04 +00005671 }else{
5672 rc = freePage(pPage);
5673 releasePage(pPage);
5674 }
5675#endif
drh2aa679f2001-06-25 02:11:07 +00005676 }else{
danielk1977a0bf2652004-11-04 14:30:04 +00005677 /* If sqlite3BtreeDropTable was called on page 1. */
drha34b6762004-05-07 13:30:42 +00005678 zeroPage(pPage, PTF_INTKEY|PTF_LEAF );
danielk1977a0bf2652004-11-04 14:30:04 +00005679 releasePage(pPage);
drh8b2f49b2001-06-08 00:21:52 +00005680 }
drh8b2f49b2001-06-08 00:21:52 +00005681 return rc;
5682}
5683
drh001bbcb2003-03-19 03:14:00 +00005684
drh8b2f49b2001-06-08 00:21:52 +00005685/*
drh23e11ca2004-05-04 17:27:28 +00005686** Read the meta-information out of a database file. Meta[0]
5687** is the number of free pages currently in the database. Meta[1]
drha3b321d2004-05-11 09:31:31 +00005688** through meta[15] are available for use by higher layers. Meta[0]
5689** is read-only, the others are read/write.
5690**
5691** The schema layer numbers meta values differently. At the schema
5692** layer (and the SetCookie and ReadCookie opcodes) the number of
5693** free pages is not visible. So Cookie[0] is the same as Meta[1].
drh8b2f49b2001-06-08 00:21:52 +00005694*/
danielk1977aef0bf62005-12-30 16:28:01 +00005695int sqlite3BtreeGetMeta(Btree *p, int idx, u32 *pMeta){
drh8b2f49b2001-06-08 00:21:52 +00005696 int rc;
drh4b70f112004-05-02 21:12:19 +00005697 unsigned char *pP1;
danielk1977aef0bf62005-12-30 16:28:01 +00005698 BtShared *pBt = p->pBt;
drh8b2f49b2001-06-08 00:21:52 +00005699
danielk1977da184232006-01-05 11:34:32 +00005700 /* Reading a meta-data value requires a read-lock on page 1 (and hence
5701 ** the sqlite_master table. We grab this lock regardless of whether or
5702 ** not the SQLITE_ReadUncommitted flag is set (the table rooted at page
5703 ** 1 is treated as a special case by queryTableLock() and lockTable()).
5704 */
5705 rc = queryTableLock(p, 1, READ_LOCK);
5706 if( rc!=SQLITE_OK ){
5707 return rc;
5708 }
5709
drh23e11ca2004-05-04 17:27:28 +00005710 assert( idx>=0 && idx<=15 );
drha34b6762004-05-07 13:30:42 +00005711 rc = sqlite3pager_get(pBt->pPager, 1, (void**)&pP1);
drh8b2f49b2001-06-08 00:21:52 +00005712 if( rc ) return rc;
drh23e11ca2004-05-04 17:27:28 +00005713 *pMeta = get4byte(&pP1[36 + idx*4]);
drha34b6762004-05-07 13:30:42 +00005714 sqlite3pager_unref(pP1);
drhae157872004-08-14 19:20:09 +00005715
danielk1977599fcba2004-11-08 07:13:13 +00005716 /* If autovacuumed is disabled in this build but we are trying to
5717 ** access an autovacuumed database, then make the database readonly.
5718 */
danielk1977003ba062004-11-04 02:57:33 +00005719#ifdef SQLITE_OMIT_AUTOVACUUM
drhae157872004-08-14 19:20:09 +00005720 if( idx==4 && *pMeta>0 ) pBt->readOnly = 1;
danielk1977003ba062004-11-04 02:57:33 +00005721#endif
drhae157872004-08-14 19:20:09 +00005722
danielk1977da184232006-01-05 11:34:32 +00005723 /* Grab the read-lock on page 1. */
5724 rc = lockTable(p, 1, READ_LOCK);
5725 return rc;
drh8b2f49b2001-06-08 00:21:52 +00005726}
5727
5728/*
drh23e11ca2004-05-04 17:27:28 +00005729** Write meta-information back into the database. Meta[0] is
5730** read-only and may not be written.
drh8b2f49b2001-06-08 00:21:52 +00005731*/
danielk1977aef0bf62005-12-30 16:28:01 +00005732int sqlite3BtreeUpdateMeta(Btree *p, int idx, u32 iMeta){
5733 BtShared *pBt = p->pBt;
drh4b70f112004-05-02 21:12:19 +00005734 unsigned char *pP1;
drha34b6762004-05-07 13:30:42 +00005735 int rc;
drh23e11ca2004-05-04 17:27:28 +00005736 assert( idx>=1 && idx<=15 );
danielk1977aef0bf62005-12-30 16:28:01 +00005737 if( p->inTrans!=TRANS_WRITE ){
drhf74b8d92002-09-01 23:20:45 +00005738 return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR;
drh5df72a52002-06-06 23:16:05 +00005739 }
drhde647132004-05-07 17:57:49 +00005740 assert( pBt->pPage1!=0 );
5741 pP1 = pBt->pPage1->aData;
drha34b6762004-05-07 13:30:42 +00005742 rc = sqlite3pager_write(pP1);
drh4b70f112004-05-02 21:12:19 +00005743 if( rc ) return rc;
drh23e11ca2004-05-04 17:27:28 +00005744 put4byte(&pP1[36 + idx*4], iMeta);
drh8b2f49b2001-06-08 00:21:52 +00005745 return SQLITE_OK;
5746}
drh8c42ca92001-06-22 19:15:00 +00005747
drhf328bc82004-05-10 23:29:49 +00005748/*
5749** Return the flag byte at the beginning of the page that the cursor
5750** is currently pointing to.
5751*/
5752int sqlite3BtreeFlags(BtCursor *pCur){
danielk1977da184232006-01-05 11:34:32 +00005753 /* TODO: What about CURSOR_REQUIRESEEK state? Probably need to call
drh777e4c42006-01-13 04:31:58 +00005754 ** restoreOrClearCursorPosition() here.
danielk1977da184232006-01-05 11:34:32 +00005755 */
drhf328bc82004-05-10 23:29:49 +00005756 MemPage *pPage = pCur->pPage;
5757 return pPage ? pPage->aData[pPage->hdrOffset] : 0;
5758}
5759
danielk1977b5402fb2005-01-12 07:15:04 +00005760#ifdef SQLITE_DEBUG
drh8c42ca92001-06-22 19:15:00 +00005761/*
5762** Print a disassembly of the given page on standard output. This routine
5763** is used for debugging and testing only.
5764*/
danielk1977aef0bf62005-12-30 16:28:01 +00005765static int btreePageDump(BtShared *pBt, int pgno, int recursive, MemPage *pParent){
drh8c42ca92001-06-22 19:15:00 +00005766 int rc;
5767 MemPage *pPage;
drhc8629a12004-05-08 20:07:40 +00005768 int i, j, c;
drh8c42ca92001-06-22 19:15:00 +00005769 int nFree;
5770 u16 idx;
drhab9f7f12004-05-08 10:56:11 +00005771 int hdr;
drh43605152004-05-29 21:46:49 +00005772 int nCell;
drha2fce642004-06-05 00:01:44 +00005773 int isInit;
drhab9f7f12004-05-08 10:56:11 +00005774 unsigned char *data;
drh8c42ca92001-06-22 19:15:00 +00005775 char range[20];
5776 unsigned char payload[20];
drhab9f7f12004-05-08 10:56:11 +00005777
drh4b70f112004-05-02 21:12:19 +00005778 rc = getPage(pBt, (Pgno)pgno, &pPage);
drha2fce642004-06-05 00:01:44 +00005779 isInit = pPage->isInit;
5780 if( pPage->isInit==0 ){
danielk1977c7dc7532004-11-17 10:22:03 +00005781 initPage(pPage, pParent);
drha2fce642004-06-05 00:01:44 +00005782 }
drh8c42ca92001-06-22 19:15:00 +00005783 if( rc ){
5784 return rc;
5785 }
drhab9f7f12004-05-08 10:56:11 +00005786 hdr = pPage->hdrOffset;
5787 data = pPage->aData;
drhc8629a12004-05-08 20:07:40 +00005788 c = data[hdr];
drh8b18dd42004-05-12 19:18:15 +00005789 pPage->intKey = (c & (PTF_INTKEY|PTF_LEAFDATA))!=0;
drhc8629a12004-05-08 20:07:40 +00005790 pPage->zeroData = (c & PTF_ZERODATA)!=0;
drh8b18dd42004-05-12 19:18:15 +00005791 pPage->leafData = (c & PTF_LEAFDATA)!=0;
drhc8629a12004-05-08 20:07:40 +00005792 pPage->leaf = (c & PTF_LEAF)!=0;
drh8b18dd42004-05-12 19:18:15 +00005793 pPage->hasData = !(pPage->zeroData || (!pPage->leaf && pPage->leafData));
drh43605152004-05-29 21:46:49 +00005794 nCell = get2byte(&data[hdr+3]);
drhfe63d1c2004-09-08 20:13:04 +00005795 sqlite3DebugPrintf("PAGE %d: flags=0x%02x frag=%d parent=%d\n", pgno,
drh43605152004-05-29 21:46:49 +00005796 data[hdr], data[hdr+7],
drhda200cc2004-05-09 11:51:38 +00005797 (pPage->isInit && pPage->pParent) ? pPage->pParent->pgno : 0);
drhab9f7f12004-05-08 10:56:11 +00005798 assert( hdr == (pgno==1 ? 100 : 0) );
drh43605152004-05-29 21:46:49 +00005799 idx = hdr + 12 - pPage->leaf*4;
5800 for(i=0; i<nCell; i++){
drh6f11bef2004-05-13 01:12:56 +00005801 CellInfo info;
drh4b70f112004-05-02 21:12:19 +00005802 Pgno child;
drh43605152004-05-29 21:46:49 +00005803 unsigned char *pCell;
drh6f11bef2004-05-13 01:12:56 +00005804 int sz;
drh43605152004-05-29 21:46:49 +00005805 int addr;
drh6f11bef2004-05-13 01:12:56 +00005806
drh43605152004-05-29 21:46:49 +00005807 addr = get2byte(&data[idx + 2*i]);
5808 pCell = &data[addr];
5809 parseCellPtr(pPage, pCell, &info);
drh6f11bef2004-05-13 01:12:56 +00005810 sz = info.nSize;
drh43605152004-05-29 21:46:49 +00005811 sprintf(range,"%d..%d", addr, addr+sz-1);
drh4b70f112004-05-02 21:12:19 +00005812 if( pPage->leaf ){
5813 child = 0;
5814 }else{
drh43605152004-05-29 21:46:49 +00005815 child = get4byte(pCell);
drh4b70f112004-05-02 21:12:19 +00005816 }
drh6f11bef2004-05-13 01:12:56 +00005817 sz = info.nData;
5818 if( !pPage->intKey ) sz += info.nKey;
drh8c42ca92001-06-22 19:15:00 +00005819 if( sz>sizeof(payload)-1 ) sz = sizeof(payload)-1;
drh6f11bef2004-05-13 01:12:56 +00005820 memcpy(payload, &pCell[info.nHeader], sz);
drh8c42ca92001-06-22 19:15:00 +00005821 for(j=0; j<sz; j++){
5822 if( payload[j]<0x20 || payload[j]>0x7f ) payload[j] = '.';
5823 }
5824 payload[sz] = 0;
drhfe63d1c2004-09-08 20:13:04 +00005825 sqlite3DebugPrintf(
drh6f11bef2004-05-13 01:12:56 +00005826 "cell %2d: i=%-10s chld=%-4d nk=%-4lld nd=%-4d payload=%s\n",
5827 i, range, child, info.nKey, info.nData, payload
drh8c42ca92001-06-22 19:15:00 +00005828 );
drh8c42ca92001-06-22 19:15:00 +00005829 }
drh4b70f112004-05-02 21:12:19 +00005830 if( !pPage->leaf ){
drhfe63d1c2004-09-08 20:13:04 +00005831 sqlite3DebugPrintf("right_child: %d\n", get4byte(&data[hdr+8]));
drh4b70f112004-05-02 21:12:19 +00005832 }
drh8c42ca92001-06-22 19:15:00 +00005833 nFree = 0;
5834 i = 0;
drhab9f7f12004-05-08 10:56:11 +00005835 idx = get2byte(&data[hdr+1]);
drhb6f41482004-05-14 01:58:11 +00005836 while( idx>0 && idx<pPage->pBt->usableSize ){
drhab9f7f12004-05-08 10:56:11 +00005837 int sz = get2byte(&data[idx+2]);
drh4b70f112004-05-02 21:12:19 +00005838 sprintf(range,"%d..%d", idx, idx+sz-1);
5839 nFree += sz;
drhfe63d1c2004-09-08 20:13:04 +00005840 sqlite3DebugPrintf("freeblock %2d: i=%-10s size=%-4d total=%d\n",
drh4b70f112004-05-02 21:12:19 +00005841 i, range, sz, nFree);
drhab9f7f12004-05-08 10:56:11 +00005842 idx = get2byte(&data[idx]);
drh2aa679f2001-06-25 02:11:07 +00005843 i++;
drh8c42ca92001-06-22 19:15:00 +00005844 }
5845 if( idx!=0 ){
drhfe63d1c2004-09-08 20:13:04 +00005846 sqlite3DebugPrintf("ERROR: next freeblock index out of range: %d\n", idx);
drh8c42ca92001-06-22 19:15:00 +00005847 }
drha34b6762004-05-07 13:30:42 +00005848 if( recursive && !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00005849 for(i=0; i<nCell; i++){
5850 unsigned char *pCell = findCell(pPage, i);
danielk1977c7dc7532004-11-17 10:22:03 +00005851 btreePageDump(pBt, get4byte(pCell), 1, pPage);
drha34b6762004-05-07 13:30:42 +00005852 idx = get2byte(pCell);
drh6019e162001-07-02 17:51:45 +00005853 }
danielk1977c7dc7532004-11-17 10:22:03 +00005854 btreePageDump(pBt, get4byte(&data[hdr+8]), 1, pPage);
drh6019e162001-07-02 17:51:45 +00005855 }
drha2fce642004-06-05 00:01:44 +00005856 pPage->isInit = isInit;
drhab9f7f12004-05-08 10:56:11 +00005857 sqlite3pager_unref(data);
drh3644f082004-05-10 18:45:09 +00005858 fflush(stdout);
drh8c42ca92001-06-22 19:15:00 +00005859 return SQLITE_OK;
5860}
danielk1977aef0bf62005-12-30 16:28:01 +00005861int sqlite3BtreePageDump(Btree *p, int pgno, int recursive){
5862 return btreePageDump(p->pBt, pgno, recursive, 0);
danielk1977c7dc7532004-11-17 10:22:03 +00005863}
drhaaab5722002-02-19 13:39:21 +00005864#endif
drh8c42ca92001-06-22 19:15:00 +00005865
drh77bba592006-08-13 18:39:26 +00005866#if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
drh8c42ca92001-06-22 19:15:00 +00005867/*
drh2aa679f2001-06-25 02:11:07 +00005868** Fill aResult[] with information about the entry and page that the
5869** cursor is pointing to.
5870**
5871** aResult[0] = The page number
5872** aResult[1] = The entry number
5873** aResult[2] = Total number of entries on this page
drh3e27c022004-07-23 00:01:38 +00005874** aResult[3] = Cell size (local payload + header)
drh2aa679f2001-06-25 02:11:07 +00005875** aResult[4] = Number of free bytes on this page
5876** aResult[5] = Number of free blocks on the page
drh3e27c022004-07-23 00:01:38 +00005877** aResult[6] = Total payload size (local + overflow)
5878** aResult[7] = Header size in bytes
5879** aResult[8] = Local payload size
5880** aResult[9] = Parent page number
drh5eddca62001-06-30 21:53:53 +00005881**
5882** This routine is used for testing and debugging only.
drh8c42ca92001-06-22 19:15:00 +00005883*/
drh3e27c022004-07-23 00:01:38 +00005884int sqlite3BtreeCursorInfo(BtCursor *pCur, int *aResult, int upCnt){
drh2aa679f2001-06-25 02:11:07 +00005885 int cnt, idx;
5886 MemPage *pPage = pCur->pPage;
drh3e27c022004-07-23 00:01:38 +00005887 BtCursor tmpCur;
drhda200cc2004-05-09 11:51:38 +00005888
drh777e4c42006-01-13 04:31:58 +00005889 int rc = restoreOrClearCursorPosition(pCur, 1);
danielk1977da184232006-01-05 11:34:32 +00005890 if( rc!=SQLITE_OK ){
5891 return rc;
5892 }
5893
drh4b70f112004-05-02 21:12:19 +00005894 assert( pPage->isInit );
drh3e27c022004-07-23 00:01:38 +00005895 getTempCursor(pCur, &tmpCur);
5896 while( upCnt-- ){
5897 moveToParent(&tmpCur);
5898 }
5899 pPage = tmpCur.pPage;
drha34b6762004-05-07 13:30:42 +00005900 aResult[0] = sqlite3pager_pagenumber(pPage->aData);
drh91025292004-05-03 19:49:32 +00005901 assert( aResult[0]==pPage->pgno );
drh3e27c022004-07-23 00:01:38 +00005902 aResult[1] = tmpCur.idx;
drh2aa679f2001-06-25 02:11:07 +00005903 aResult[2] = pPage->nCell;
drh3e27c022004-07-23 00:01:38 +00005904 if( tmpCur.idx>=0 && tmpCur.idx<pPage->nCell ){
5905 getCellInfo(&tmpCur);
5906 aResult[3] = tmpCur.info.nSize;
5907 aResult[6] = tmpCur.info.nData;
5908 aResult[7] = tmpCur.info.nHeader;
5909 aResult[8] = tmpCur.info.nLocal;
drh2aa679f2001-06-25 02:11:07 +00005910 }else{
5911 aResult[3] = 0;
5912 aResult[6] = 0;
drh3e27c022004-07-23 00:01:38 +00005913 aResult[7] = 0;
5914 aResult[8] = 0;
drh2aa679f2001-06-25 02:11:07 +00005915 }
5916 aResult[4] = pPage->nFree;
5917 cnt = 0;
drh4b70f112004-05-02 21:12:19 +00005918 idx = get2byte(&pPage->aData[pPage->hdrOffset+1]);
drhb6f41482004-05-14 01:58:11 +00005919 while( idx>0 && idx<pPage->pBt->usableSize ){
drh2aa679f2001-06-25 02:11:07 +00005920 cnt++;
drh4b70f112004-05-02 21:12:19 +00005921 idx = get2byte(&pPage->aData[idx]);
drh2aa679f2001-06-25 02:11:07 +00005922 }
5923 aResult[5] = cnt;
drh3e27c022004-07-23 00:01:38 +00005924 if( pPage->pParent==0 || isRootPage(pPage) ){
5925 aResult[9] = 0;
5926 }else{
5927 aResult[9] = pPage->pParent->pgno;
5928 }
5929 releaseTempCursor(&tmpCur);
drh8c42ca92001-06-22 19:15:00 +00005930 return SQLITE_OK;
5931}
drhaaab5722002-02-19 13:39:21 +00005932#endif
drhdd793422001-06-28 01:54:48 +00005933
drhdd793422001-06-28 01:54:48 +00005934/*
drh5eddca62001-06-30 21:53:53 +00005935** Return the pager associated with a BTree. This routine is used for
5936** testing and debugging only.
drhdd793422001-06-28 01:54:48 +00005937*/
danielk1977aef0bf62005-12-30 16:28:01 +00005938Pager *sqlite3BtreePager(Btree *p){
5939 return p->pBt->pPager;
drhdd793422001-06-28 01:54:48 +00005940}
drh5eddca62001-06-30 21:53:53 +00005941
5942/*
5943** This structure is passed around through all the sanity checking routines
5944** in order to keep track of some global state information.
5945*/
drhaaab5722002-02-19 13:39:21 +00005946typedef struct IntegrityCk IntegrityCk;
5947struct IntegrityCk {
danielk1977aef0bf62005-12-30 16:28:01 +00005948 BtShared *pBt; /* The tree being checked out */
drh100569d2001-10-02 13:01:48 +00005949 Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */
5950 int nPage; /* Number of pages in the database */
5951 int *anRef; /* Number of times each page is referenced */
drh100569d2001-10-02 13:01:48 +00005952 char *zErrMsg; /* An error message. NULL of no errors seen. */
drh5eddca62001-06-30 21:53:53 +00005953};
5954
drhb7f91642004-10-31 02:22:47 +00005955#ifndef SQLITE_OMIT_INTEGRITY_CHECK
drh5eddca62001-06-30 21:53:53 +00005956/*
5957** Append a message to the error message string.
5958*/
drh2e38c322004-09-03 18:38:44 +00005959static void checkAppendMsg(
5960 IntegrityCk *pCheck,
5961 char *zMsg1,
5962 const char *zFormat,
5963 ...
5964){
5965 va_list ap;
5966 char *zMsg2;
5967 va_start(ap, zFormat);
5968 zMsg2 = sqlite3VMPrintf(zFormat, ap);
5969 va_end(ap);
5970 if( zMsg1==0 ) zMsg1 = "";
drh5eddca62001-06-30 21:53:53 +00005971 if( pCheck->zErrMsg ){
5972 char *zOld = pCheck->zErrMsg;
5973 pCheck->zErrMsg = 0;
danielk19774adee202004-05-08 08:23:19 +00005974 sqlite3SetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0);
drh5eddca62001-06-30 21:53:53 +00005975 sqliteFree(zOld);
5976 }else{
danielk19774adee202004-05-08 08:23:19 +00005977 sqlite3SetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0);
drh5eddca62001-06-30 21:53:53 +00005978 }
drh2e38c322004-09-03 18:38:44 +00005979 sqliteFree(zMsg2);
drh5eddca62001-06-30 21:53:53 +00005980}
drhb7f91642004-10-31 02:22:47 +00005981#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
drh5eddca62001-06-30 21:53:53 +00005982
drhb7f91642004-10-31 02:22:47 +00005983#ifndef SQLITE_OMIT_INTEGRITY_CHECK
drh5eddca62001-06-30 21:53:53 +00005984/*
5985** Add 1 to the reference count for page iPage. If this is the second
5986** reference to the page, add an error message to pCheck->zErrMsg.
5987** Return 1 if there are 2 ore more references to the page and 0 if
5988** if this is the first reference to the page.
5989**
5990** Also check that the page number is in bounds.
5991*/
drhaaab5722002-02-19 13:39:21 +00005992static int checkRef(IntegrityCk *pCheck, int iPage, char *zContext){
drh5eddca62001-06-30 21:53:53 +00005993 if( iPage==0 ) return 1;
drh0de8c112002-07-06 16:32:14 +00005994 if( iPage>pCheck->nPage || iPage<0 ){
drh2e38c322004-09-03 18:38:44 +00005995 checkAppendMsg(pCheck, zContext, "invalid page number %d", iPage);
drh5eddca62001-06-30 21:53:53 +00005996 return 1;
5997 }
5998 if( pCheck->anRef[iPage]==1 ){
drh2e38c322004-09-03 18:38:44 +00005999 checkAppendMsg(pCheck, zContext, "2nd reference to page %d", iPage);
drh5eddca62001-06-30 21:53:53 +00006000 return 1;
6001 }
6002 return (pCheck->anRef[iPage]++)>1;
6003}
6004
danielk1977afcdd022004-10-31 16:25:42 +00006005#ifndef SQLITE_OMIT_AUTOVACUUM
6006/*
6007** Check that the entry in the pointer-map for page iChild maps to
6008** page iParent, pointer type ptrType. If not, append an error message
6009** to pCheck.
6010*/
6011static void checkPtrmap(
6012 IntegrityCk *pCheck, /* Integrity check context */
6013 Pgno iChild, /* Child page number */
6014 u8 eType, /* Expected pointer map type */
6015 Pgno iParent, /* Expected pointer map parent page number */
6016 char *zContext /* Context description (used for error msg) */
6017){
6018 int rc;
6019 u8 ePtrmapType;
6020 Pgno iPtrmapParent;
6021
6022 rc = ptrmapGet(pCheck->pBt, iChild, &ePtrmapType, &iPtrmapParent);
6023 if( rc!=SQLITE_OK ){
6024 checkAppendMsg(pCheck, zContext, "Failed to read ptrmap key=%d", iChild);
6025 return;
6026 }
6027
6028 if( ePtrmapType!=eType || iPtrmapParent!=iParent ){
6029 checkAppendMsg(pCheck, zContext,
6030 "Bad ptr map entry key=%d expected=(%d,%d) got=(%d,%d)",
6031 iChild, eType, iParent, ePtrmapType, iPtrmapParent);
6032 }
6033}
6034#endif
6035
drh5eddca62001-06-30 21:53:53 +00006036/*
6037** Check the integrity of the freelist or of an overflow page list.
6038** Verify that the number of pages on the list is N.
6039*/
drh30e58752002-03-02 20:41:57 +00006040static void checkList(
6041 IntegrityCk *pCheck, /* Integrity checking context */
6042 int isFreeList, /* True for a freelist. False for overflow page list */
6043 int iPage, /* Page number for first page in the list */
6044 int N, /* Expected number of pages in the list */
6045 char *zContext /* Context for error messages */
6046){
6047 int i;
drh3a4c1412004-05-09 20:40:11 +00006048 int expected = N;
6049 int iFirst = iPage;
drh30e58752002-03-02 20:41:57 +00006050 while( N-- > 0 ){
drh4b70f112004-05-02 21:12:19 +00006051 unsigned char *pOvfl;
drh5eddca62001-06-30 21:53:53 +00006052 if( iPage<1 ){
drh2e38c322004-09-03 18:38:44 +00006053 checkAppendMsg(pCheck, zContext,
6054 "%d of %d pages missing from overflow list starting at %d",
drh3a4c1412004-05-09 20:40:11 +00006055 N+1, expected, iFirst);
drh5eddca62001-06-30 21:53:53 +00006056 break;
6057 }
6058 if( checkRef(pCheck, iPage, zContext) ) break;
drha34b6762004-05-07 13:30:42 +00006059 if( sqlite3pager_get(pCheck->pPager, (Pgno)iPage, (void**)&pOvfl) ){
drh2e38c322004-09-03 18:38:44 +00006060 checkAppendMsg(pCheck, zContext, "failed to get page %d", iPage);
drh5eddca62001-06-30 21:53:53 +00006061 break;
6062 }
drh30e58752002-03-02 20:41:57 +00006063 if( isFreeList ){
drh4b70f112004-05-02 21:12:19 +00006064 int n = get4byte(&pOvfl[4]);
danielk1977687566d2004-11-02 12:56:41 +00006065#ifndef SQLITE_OMIT_AUTOVACUUM
6066 if( pCheck->pBt->autoVacuum ){
6067 checkPtrmap(pCheck, iPage, PTRMAP_FREEPAGE, 0, zContext);
6068 }
6069#endif
drh855eb1c2004-08-31 13:45:11 +00006070 if( n>pCheck->pBt->usableSize/4-8 ){
drh2e38c322004-09-03 18:38:44 +00006071 checkAppendMsg(pCheck, zContext,
6072 "freelist leaf count too big on page %d", iPage);
drhee696e22004-08-30 16:52:17 +00006073 N--;
6074 }else{
6075 for(i=0; i<n; i++){
danielk1977687566d2004-11-02 12:56:41 +00006076 Pgno iFreePage = get4byte(&pOvfl[8+i*4]);
6077#ifndef SQLITE_OMIT_AUTOVACUUM
6078 if( pCheck->pBt->autoVacuum ){
6079 checkPtrmap(pCheck, iFreePage, PTRMAP_FREEPAGE, 0, zContext);
6080 }
6081#endif
6082 checkRef(pCheck, iFreePage, zContext);
drhee696e22004-08-30 16:52:17 +00006083 }
6084 N -= n;
drh30e58752002-03-02 20:41:57 +00006085 }
drh30e58752002-03-02 20:41:57 +00006086 }
danielk1977afcdd022004-10-31 16:25:42 +00006087#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977687566d2004-11-02 12:56:41 +00006088 else{
6089 /* If this database supports auto-vacuum and iPage is not the last
6090 ** page in this overflow list, check that the pointer-map entry for
6091 ** the following page matches iPage.
6092 */
6093 if( pCheck->pBt->autoVacuum && N>0 ){
6094 i = get4byte(pOvfl);
6095 checkPtrmap(pCheck, i, PTRMAP_OVERFLOW2, iPage, zContext);
6096 }
danielk1977afcdd022004-10-31 16:25:42 +00006097 }
6098#endif
drh4b70f112004-05-02 21:12:19 +00006099 iPage = get4byte(pOvfl);
drha34b6762004-05-07 13:30:42 +00006100 sqlite3pager_unref(pOvfl);
drh5eddca62001-06-30 21:53:53 +00006101 }
6102}
drhb7f91642004-10-31 02:22:47 +00006103#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
drh5eddca62001-06-30 21:53:53 +00006104
drhb7f91642004-10-31 02:22:47 +00006105#ifndef SQLITE_OMIT_INTEGRITY_CHECK
drh5eddca62001-06-30 21:53:53 +00006106/*
6107** Do various sanity checks on a single page of a tree. Return
6108** the tree depth. Root pages return 0. Parents of root pages
6109** return 1, and so forth.
6110**
6111** These checks are done:
6112**
6113** 1. Make sure that cells and freeblocks do not overlap
6114** but combine to completely cover the page.
drhda200cc2004-05-09 11:51:38 +00006115** NO 2. Make sure cell keys are in order.
6116** NO 3. Make sure no key is less than or equal to zLowerBound.
6117** NO 4. Make sure no key is greater than or equal to zUpperBound.
drh5eddca62001-06-30 21:53:53 +00006118** 5. Check the integrity of overflow pages.
6119** 6. Recursively call checkTreePage on all children.
6120** 7. Verify that the depth of all children is the same.
drh6019e162001-07-02 17:51:45 +00006121** 8. Make sure this page is at least 33% full or else it is
drh5eddca62001-06-30 21:53:53 +00006122** the root of the tree.
6123*/
6124static int checkTreePage(
drhaaab5722002-02-19 13:39:21 +00006125 IntegrityCk *pCheck, /* Context for the sanity check */
drh5eddca62001-06-30 21:53:53 +00006126 int iPage, /* Page number of the page to check */
6127 MemPage *pParent, /* Parent page */
drh74161702006-02-24 02:53:49 +00006128 char *zParentContext /* Parent context */
drh5eddca62001-06-30 21:53:53 +00006129){
6130 MemPage *pPage;
drhda200cc2004-05-09 11:51:38 +00006131 int i, rc, depth, d2, pgno, cnt;
drh43605152004-05-29 21:46:49 +00006132 int hdr, cellStart;
6133 int nCell;
drhda200cc2004-05-09 11:51:38 +00006134 u8 *data;
danielk1977aef0bf62005-12-30 16:28:01 +00006135 BtShared *pBt;
drh4f26bb62005-09-08 14:17:20 +00006136 int usableSize;
drh5eddca62001-06-30 21:53:53 +00006137 char zContext[100];
drh2e38c322004-09-03 18:38:44 +00006138 char *hit;
drh5eddca62001-06-30 21:53:53 +00006139
danielk1977ef73ee92004-11-06 12:26:07 +00006140 sprintf(zContext, "Page %d: ", iPage);
6141
drh5eddca62001-06-30 21:53:53 +00006142 /* Check that the page exists
6143 */
drhd9cb6ac2005-10-20 07:28:17 +00006144 pBt = pCheck->pBt;
drhb6f41482004-05-14 01:58:11 +00006145 usableSize = pBt->usableSize;
drh5eddca62001-06-30 21:53:53 +00006146 if( iPage==0 ) return 0;
6147 if( checkRef(pCheck, iPage, zParentContext) ) return 0;
drh4b70f112004-05-02 21:12:19 +00006148 if( (rc = getPage(pBt, (Pgno)iPage, &pPage))!=0 ){
drh2e38c322004-09-03 18:38:44 +00006149 checkAppendMsg(pCheck, zContext,
6150 "unable to get the page. error code=%d", rc);
drh5eddca62001-06-30 21:53:53 +00006151 return 0;
6152 }
drh4b70f112004-05-02 21:12:19 +00006153 if( (rc = initPage(pPage, pParent))!=0 ){
drh2e38c322004-09-03 18:38:44 +00006154 checkAppendMsg(pCheck, zContext, "initPage() returns error code %d", rc);
drh91025292004-05-03 19:49:32 +00006155 releasePage(pPage);
drh5eddca62001-06-30 21:53:53 +00006156 return 0;
6157 }
6158
6159 /* Check out all the cells.
6160 */
6161 depth = 0;
drh5eddca62001-06-30 21:53:53 +00006162 for(i=0; i<pPage->nCell; i++){
drh6f11bef2004-05-13 01:12:56 +00006163 u8 *pCell;
6164 int sz;
6165 CellInfo info;
drh5eddca62001-06-30 21:53:53 +00006166
6167 /* Check payload overflow pages
6168 */
drh3a4c1412004-05-09 20:40:11 +00006169 sprintf(zContext, "On tree page %d cell %d: ", iPage, i);
drh43605152004-05-29 21:46:49 +00006170 pCell = findCell(pPage,i);
6171 parseCellPtr(pPage, pCell, &info);
drh6f11bef2004-05-13 01:12:56 +00006172 sz = info.nData;
6173 if( !pPage->intKey ) sz += info.nKey;
6174 if( sz>info.nLocal ){
drhb6f41482004-05-14 01:58:11 +00006175 int nPage = (sz - info.nLocal + usableSize - 5)/(usableSize - 4);
danielk1977afcdd022004-10-31 16:25:42 +00006176 Pgno pgnoOvfl = get4byte(&pCell[info.iOverflow]);
6177#ifndef SQLITE_OMIT_AUTOVACUUM
6178 if( pBt->autoVacuum ){
danielk1977687566d2004-11-02 12:56:41 +00006179 checkPtrmap(pCheck, pgnoOvfl, PTRMAP_OVERFLOW1, iPage, zContext);
danielk1977afcdd022004-10-31 16:25:42 +00006180 }
6181#endif
6182 checkList(pCheck, 0, pgnoOvfl, nPage, zContext);
drh5eddca62001-06-30 21:53:53 +00006183 }
6184
6185 /* Check sanity of left child page.
6186 */
drhda200cc2004-05-09 11:51:38 +00006187 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00006188 pgno = get4byte(pCell);
danielk1977afcdd022004-10-31 16:25:42 +00006189#ifndef SQLITE_OMIT_AUTOVACUUM
6190 if( pBt->autoVacuum ){
6191 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, zContext);
6192 }
6193#endif
drh74161702006-02-24 02:53:49 +00006194 d2 = checkTreePage(pCheck,pgno,pPage,zContext);
drhda200cc2004-05-09 11:51:38 +00006195 if( i>0 && d2!=depth ){
6196 checkAppendMsg(pCheck, zContext, "Child page depth differs");
6197 }
6198 depth = d2;
drh5eddca62001-06-30 21:53:53 +00006199 }
drh5eddca62001-06-30 21:53:53 +00006200 }
drhda200cc2004-05-09 11:51:38 +00006201 if( !pPage->leaf ){
drh43605152004-05-29 21:46:49 +00006202 pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
drhda200cc2004-05-09 11:51:38 +00006203 sprintf(zContext, "On page %d at right child: ", iPage);
danielk1977afcdd022004-10-31 16:25:42 +00006204#ifndef SQLITE_OMIT_AUTOVACUUM
6205 if( pBt->autoVacuum ){
danielk1977687566d2004-11-02 12:56:41 +00006206 checkPtrmap(pCheck, pgno, PTRMAP_BTREE, iPage, 0);
danielk1977afcdd022004-10-31 16:25:42 +00006207 }
6208#endif
drh74161702006-02-24 02:53:49 +00006209 checkTreePage(pCheck, pgno, pPage, zContext);
drhda200cc2004-05-09 11:51:38 +00006210 }
drh5eddca62001-06-30 21:53:53 +00006211
6212 /* Check for complete coverage of the page
6213 */
drhda200cc2004-05-09 11:51:38 +00006214 data = pPage->aData;
6215 hdr = pPage->hdrOffset;
drh2e38c322004-09-03 18:38:44 +00006216 hit = sqliteMalloc( usableSize );
6217 if( hit ){
6218 memset(hit, 1, get2byte(&data[hdr+5]));
6219 nCell = get2byte(&data[hdr+3]);
6220 cellStart = hdr + 12 - 4*pPage->leaf;
6221 for(i=0; i<nCell; i++){
6222 int pc = get2byte(&data[cellStart+i*2]);
6223 int size = cellSizePtr(pPage, &data[pc]);
6224 int j;
danielk19777701e812005-01-10 12:59:51 +00006225 if( (pc+size-1)>=usableSize || pc<0 ){
6226 checkAppendMsg(pCheck, 0,
6227 "Corruption detected in cell %d on page %d",i,iPage,0);
6228 }else{
6229 for(j=pc+size-1; j>=pc; j--) hit[j]++;
6230 }
drh2e38c322004-09-03 18:38:44 +00006231 }
6232 for(cnt=0, i=get2byte(&data[hdr+1]); i>0 && i<usableSize && cnt<10000;
6233 cnt++){
6234 int size = get2byte(&data[i+2]);
6235 int j;
danielk19777701e812005-01-10 12:59:51 +00006236 if( (i+size-1)>=usableSize || i<0 ){
6237 checkAppendMsg(pCheck, 0,
6238 "Corruption detected in cell %d on page %d",i,iPage,0);
6239 }else{
6240 for(j=i+size-1; j>=i; j--) hit[j]++;
6241 }
drh2e38c322004-09-03 18:38:44 +00006242 i = get2byte(&data[i]);
6243 }
6244 for(i=cnt=0; i<usableSize; i++){
6245 if( hit[i]==0 ){
6246 cnt++;
6247 }else if( hit[i]>1 ){
6248 checkAppendMsg(pCheck, 0,
6249 "Multiple uses for byte %d of page %d", i, iPage);
6250 break;
6251 }
6252 }
6253 if( cnt!=data[hdr+7] ){
6254 checkAppendMsg(pCheck, 0,
6255 "Fragmented space is %d byte reported as %d on page %d",
6256 cnt, data[hdr+7], iPage);
drh5eddca62001-06-30 21:53:53 +00006257 }
6258 }
drh2e38c322004-09-03 18:38:44 +00006259 sqliteFree(hit);
drh6019e162001-07-02 17:51:45 +00006260
drh4b70f112004-05-02 21:12:19 +00006261 releasePage(pPage);
drhda200cc2004-05-09 11:51:38 +00006262 return depth+1;
drh5eddca62001-06-30 21:53:53 +00006263}
drhb7f91642004-10-31 02:22:47 +00006264#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
drh5eddca62001-06-30 21:53:53 +00006265
drhb7f91642004-10-31 02:22:47 +00006266#ifndef SQLITE_OMIT_INTEGRITY_CHECK
drh5eddca62001-06-30 21:53:53 +00006267/*
6268** This routine does a complete check of the given BTree file. aRoot[] is
6269** an array of pages numbers were each page number is the root page of
6270** a table. nRoot is the number of entries in aRoot.
6271**
6272** If everything checks out, this routine returns NULL. If something is
6273** amiss, an error message is written into memory obtained from malloc()
6274** and a pointer to that error message is returned. The calling function
6275** is responsible for freeing the error message when it is done.
6276*/
danielk1977aef0bf62005-12-30 16:28:01 +00006277char *sqlite3BtreeIntegrityCheck(Btree *p, int *aRoot, int nRoot){
drh5eddca62001-06-30 21:53:53 +00006278 int i;
6279 int nRef;
drhaaab5722002-02-19 13:39:21 +00006280 IntegrityCk sCheck;
danielk1977aef0bf62005-12-30 16:28:01 +00006281 BtShared *pBt = p->pBt;
drh5eddca62001-06-30 21:53:53 +00006282
drh0f7eb612006-08-08 13:51:43 +00006283 nRef = sqlite3pager_refcount(pBt->pPager);
danielk1977aef0bf62005-12-30 16:28:01 +00006284 if( lockBtreeWithRetry(p)!=SQLITE_OK ){
drhefc251d2001-07-01 22:12:01 +00006285 return sqliteStrDup("Unable to acquire a read lock on the database");
6286 }
drh5eddca62001-06-30 21:53:53 +00006287 sCheck.pBt = pBt;
6288 sCheck.pPager = pBt->pPager;
drha34b6762004-05-07 13:30:42 +00006289 sCheck.nPage = sqlite3pager_pagecount(sCheck.pPager);
drh0de8c112002-07-06 16:32:14 +00006290 if( sCheck.nPage==0 ){
6291 unlockBtreeIfUnused(pBt);
6292 return 0;
6293 }
drh8c1238a2003-01-02 14:43:55 +00006294 sCheck.anRef = sqliteMallocRaw( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) );
danielk1977ac245ec2005-01-14 13:50:11 +00006295 if( !sCheck.anRef ){
6296 unlockBtreeIfUnused(pBt);
6297 return sqlite3MPrintf("Unable to malloc %d bytes",
6298 (sCheck.nPage+1)*sizeof(sCheck.anRef[0]));
6299 }
drhda200cc2004-05-09 11:51:38 +00006300 for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }
drh42cac6d2004-11-20 20:31:11 +00006301 i = PENDING_BYTE_PAGE(pBt);
drh1f595712004-06-15 01:40:29 +00006302 if( i<=sCheck.nPage ){
6303 sCheck.anRef[i] = 1;
6304 }
drh5eddca62001-06-30 21:53:53 +00006305 sCheck.zErrMsg = 0;
6306
6307 /* Check the integrity of the freelist
6308 */
drha34b6762004-05-07 13:30:42 +00006309 checkList(&sCheck, 1, get4byte(&pBt->pPage1->aData[32]),
6310 get4byte(&pBt->pPage1->aData[36]), "Main freelist: ");
drh5eddca62001-06-30 21:53:53 +00006311
6312 /* Check all the tables.
6313 */
6314 for(i=0; i<nRoot; i++){
drh4ff6dfa2002-03-03 23:06:00 +00006315 if( aRoot[i]==0 ) continue;
danielk1977687566d2004-11-02 12:56:41 +00006316#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977687566d2004-11-02 12:56:41 +00006317 if( pBt->autoVacuum && aRoot[i]>1 ){
6318 checkPtrmap(&sCheck, aRoot[i], PTRMAP_ROOTPAGE, 0, 0);
6319 }
6320#endif
drh74161702006-02-24 02:53:49 +00006321 checkTreePage(&sCheck, aRoot[i], 0, "List of tree roots: ");
drh5eddca62001-06-30 21:53:53 +00006322 }
6323
6324 /* Make sure every page in the file is referenced
6325 */
6326 for(i=1; i<=sCheck.nPage; i++){
danielk1977afcdd022004-10-31 16:25:42 +00006327#ifdef SQLITE_OMIT_AUTOVACUUM
drh5eddca62001-06-30 21:53:53 +00006328 if( sCheck.anRef[i]==0 ){
drh2e38c322004-09-03 18:38:44 +00006329 checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
drh5eddca62001-06-30 21:53:53 +00006330 }
danielk1977afcdd022004-10-31 16:25:42 +00006331#else
6332 /* If the database supports auto-vacuum, make sure no tables contain
6333 ** references to pointer-map pages.
6334 */
6335 if( sCheck.anRef[i]==0 &&
danielk1977266664d2006-02-10 08:24:21 +00006336 (PTRMAP_PAGENO(pBt, i)!=i || !pBt->autoVacuum) ){
danielk1977afcdd022004-10-31 16:25:42 +00006337 checkAppendMsg(&sCheck, 0, "Page %d is never used", i);
6338 }
6339 if( sCheck.anRef[i]!=0 &&
danielk1977266664d2006-02-10 08:24:21 +00006340 (PTRMAP_PAGENO(pBt, i)==i && pBt->autoVacuum) ){
danielk1977afcdd022004-10-31 16:25:42 +00006341 checkAppendMsg(&sCheck, 0, "Pointer map page %d is referenced", i);
6342 }
6343#endif
drh5eddca62001-06-30 21:53:53 +00006344 }
6345
6346 /* Make sure this analysis did not leave any unref() pages
6347 */
drh5e00f6c2001-09-13 13:46:56 +00006348 unlockBtreeIfUnused(pBt);
drh0f7eb612006-08-08 13:51:43 +00006349 if( nRef != sqlite3pager_refcount(pBt->pPager) ){
drh2e38c322004-09-03 18:38:44 +00006350 checkAppendMsg(&sCheck, 0,
drh5eddca62001-06-30 21:53:53 +00006351 "Outstanding page count goes from %d to %d during this analysis",
drh0f7eb612006-08-08 13:51:43 +00006352 nRef, sqlite3pager_refcount(pBt->pPager)
drh5eddca62001-06-30 21:53:53 +00006353 );
drh5eddca62001-06-30 21:53:53 +00006354 }
6355
6356 /* Clean up and report errors.
6357 */
6358 sqliteFree(sCheck.anRef);
6359 return sCheck.zErrMsg;
6360}
drhb7f91642004-10-31 02:22:47 +00006361#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
paulb95a8862003-04-01 21:16:41 +00006362
drh73509ee2003-04-06 20:44:45 +00006363/*
6364** Return the full pathname of the underlying database file.
6365*/
danielk1977aef0bf62005-12-30 16:28:01 +00006366const char *sqlite3BtreeGetFilename(Btree *p){
6367 assert( p->pBt->pPager!=0 );
6368 return sqlite3pager_filename(p->pBt->pPager);
drh73509ee2003-04-06 20:44:45 +00006369}
6370
6371/*
danielk19775865e3d2004-06-14 06:03:57 +00006372** Return the pathname of the directory that contains the database file.
6373*/
danielk1977aef0bf62005-12-30 16:28:01 +00006374const char *sqlite3BtreeGetDirname(Btree *p){
6375 assert( p->pBt->pPager!=0 );
6376 return sqlite3pager_dirname(p->pBt->pPager);
danielk19775865e3d2004-06-14 06:03:57 +00006377}
6378
6379/*
6380** Return the pathname of the journal file for this database. The return
6381** value of this routine is the same regardless of whether the journal file
6382** has been created or not.
6383*/
danielk1977aef0bf62005-12-30 16:28:01 +00006384const char *sqlite3BtreeGetJournalname(Btree *p){
6385 assert( p->pBt->pPager!=0 );
6386 return sqlite3pager_journalname(p->pBt->pPager);
danielk19775865e3d2004-06-14 06:03:57 +00006387}
6388
drhb7f91642004-10-31 02:22:47 +00006389#ifndef SQLITE_OMIT_VACUUM
danielk19775865e3d2004-06-14 06:03:57 +00006390/*
drhf7c57532003-04-25 13:22:51 +00006391** Copy the complete content of pBtFrom into pBtTo. A transaction
6392** must be active for both files.
6393**
6394** The size of file pBtFrom may be reduced by this operation.
drh43605152004-05-29 21:46:49 +00006395** If anything goes wrong, the transaction on pBtFrom is rolled back.
drh73509ee2003-04-06 20:44:45 +00006396*/
danielk1977aef0bf62005-12-30 16:28:01 +00006397int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
drhf7c57532003-04-25 13:22:51 +00006398 int rc = SQLITE_OK;
drh50f2f432005-09-16 11:32:18 +00006399 Pgno i, nPage, nToPage, iSkip;
drhf7c57532003-04-25 13:22:51 +00006400
danielk1977aef0bf62005-12-30 16:28:01 +00006401 BtShared *pBtTo = pTo->pBt;
6402 BtShared *pBtFrom = pFrom->pBt;
6403
6404 if( pTo->inTrans!=TRANS_WRITE || pFrom->inTrans!=TRANS_WRITE ){
danielk1977ee5741e2004-05-31 10:01:34 +00006405 return SQLITE_ERROR;
6406 }
drhf7c57532003-04-25 13:22:51 +00006407 if( pBtTo->pCursor ) return SQLITE_BUSY;
drha34b6762004-05-07 13:30:42 +00006408 nToPage = sqlite3pager_pagecount(pBtTo->pPager);
6409 nPage = sqlite3pager_pagecount(pBtFrom->pPager);
drh50f2f432005-09-16 11:32:18 +00006410 iSkip = PENDING_BYTE_PAGE(pBtTo);
danielk1977369f27e2004-06-15 11:40:04 +00006411 for(i=1; rc==SQLITE_OK && i<=nPage; i++){
drhf7c57532003-04-25 13:22:51 +00006412 void *pPage;
drh50f2f432005-09-16 11:32:18 +00006413 if( i==iSkip ) continue;
drha34b6762004-05-07 13:30:42 +00006414 rc = sqlite3pager_get(pBtFrom->pPager, i, &pPage);
drhf7c57532003-04-25 13:22:51 +00006415 if( rc ) break;
drha34b6762004-05-07 13:30:42 +00006416 rc = sqlite3pager_overwrite(pBtTo->pPager, i, pPage);
drh2e6d11b2003-04-25 15:37:57 +00006417 if( rc ) break;
drha34b6762004-05-07 13:30:42 +00006418 sqlite3pager_unref(pPage);
drhf7c57532003-04-25 13:22:51 +00006419 }
drh2e6d11b2003-04-25 15:37:57 +00006420 for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){
6421 void *pPage;
drh49285702005-09-17 15:20:26 +00006422 if( i==iSkip ) continue;
drha34b6762004-05-07 13:30:42 +00006423 rc = sqlite3pager_get(pBtTo->pPager, i, &pPage);
drh2e6d11b2003-04-25 15:37:57 +00006424 if( rc ) break;
drha34b6762004-05-07 13:30:42 +00006425 rc = sqlite3pager_write(pPage);
6426 sqlite3pager_unref(pPage);
6427 sqlite3pager_dont_write(pBtTo->pPager, i);
drh2e6d11b2003-04-25 15:37:57 +00006428 }
6429 if( !rc && nPage<nToPage ){
drha34b6762004-05-07 13:30:42 +00006430 rc = sqlite3pager_truncate(pBtTo->pPager, nPage);
drh2e6d11b2003-04-25 15:37:57 +00006431 }
drhf7c57532003-04-25 13:22:51 +00006432 if( rc ){
danielk1977aef0bf62005-12-30 16:28:01 +00006433 sqlite3BtreeRollback(pTo);
drhf7c57532003-04-25 13:22:51 +00006434 }
6435 return rc;
drh73509ee2003-04-06 20:44:45 +00006436}
drhb7f91642004-10-31 02:22:47 +00006437#endif /* SQLITE_OMIT_VACUUM */
danielk19771d850a72004-05-31 08:26:49 +00006438
6439/*
6440** Return non-zero if a transaction is active.
6441*/
danielk1977aef0bf62005-12-30 16:28:01 +00006442int sqlite3BtreeIsInTrans(Btree *p){
6443 return (p && (p->inTrans==TRANS_WRITE));
danielk19771d850a72004-05-31 08:26:49 +00006444}
6445
6446/*
6447** Return non-zero if a statement transaction is active.
6448*/
danielk1977aef0bf62005-12-30 16:28:01 +00006449int sqlite3BtreeIsInStmt(Btree *p){
6450 return (p->pBt && p->pBt->inStmt);
danielk19771d850a72004-05-31 08:26:49 +00006451}
danielk197713adf8a2004-06-03 16:08:41 +00006452
6453/*
danielk19772372c2b2006-06-27 16:34:56 +00006454** Return non-zero if a read (or write) transaction is active.
6455*/
6456int sqlite3BtreeIsInReadTrans(Btree *p){
6457 return (p && (p->inTrans!=TRANS_NONE));
6458}
6459
6460/*
danielk197713adf8a2004-06-03 16:08:41 +00006461** This call is a no-op if no write-transaction is currently active on pBt.
6462**
6463** Otherwise, sync the database file for the btree pBt. zMaster points to
6464** the name of a master journal file that should be written into the
6465** individual journal file, or is NULL, indicating no master journal file
6466** (single database transaction).
6467**
6468** When this is called, the master journal should already have been
6469** created, populated with this journal pointer and synced to disk.
6470**
6471** Once this is routine has returned, the only thing required to commit
6472** the write-transaction for this database file is to delete the journal.
6473*/
danielk1977aef0bf62005-12-30 16:28:01 +00006474int sqlite3BtreeSync(Btree *p, const char *zMaster){
danielk1977266664d2006-02-10 08:24:21 +00006475 int rc = SQLITE_OK;
danielk1977aef0bf62005-12-30 16:28:01 +00006476 if( p->inTrans==TRANS_WRITE ){
6477 BtShared *pBt = p->pBt;
danielk1977d761c0c2004-11-05 16:37:02 +00006478 Pgno nTrunc = 0;
danielk1977266664d2006-02-10 08:24:21 +00006479#ifndef SQLITE_OMIT_AUTOVACUUM
danielk1977687566d2004-11-02 12:56:41 +00006480 if( pBt->autoVacuum ){
danielk1977266664d2006-02-10 08:24:21 +00006481 rc = autoVacuumCommit(pBt, &nTrunc);
6482 if( rc!=SQLITE_OK ){
6483 return rc;
6484 }
danielk1977687566d2004-11-02 12:56:41 +00006485 }
6486#endif
danielk1977266664d2006-02-10 08:24:21 +00006487 rc = sqlite3pager_sync(pBt->pPager, zMaster, nTrunc);
danielk197713adf8a2004-06-03 16:08:41 +00006488 }
danielk1977266664d2006-02-10 08:24:21 +00006489 return rc;
danielk197713adf8a2004-06-03 16:08:41 +00006490}
danielk1977aef0bf62005-12-30 16:28:01 +00006491
danielk1977da184232006-01-05 11:34:32 +00006492/*
6493** This function returns a pointer to a blob of memory associated with
6494** a single shared-btree. The memory is used by client code for it's own
6495** purposes (for example, to store a high-level schema associated with
6496** the shared-btree). The btree layer manages reference counting issues.
6497**
6498** The first time this is called on a shared-btree, nBytes bytes of memory
6499** are allocated, zeroed, and returned to the caller. For each subsequent
6500** call the nBytes parameter is ignored and a pointer to the same blob
6501** of memory returned.
6502**
6503** Just before the shared-btree is closed, the function passed as the
6504** xFree argument when the memory allocation was made is invoked on the
6505** blob of allocated memory. This function should not call sqliteFree()
6506** on the memory, the btree layer does that.
6507*/
6508void *sqlite3BtreeSchema(Btree *p, int nBytes, void(*xFree)(void *)){
6509 BtShared *pBt = p->pBt;
6510 if( !pBt->pSchema ){
6511 pBt->pSchema = sqliteMalloc(nBytes);
6512 pBt->xFreeSchema = xFree;
6513 }
6514 return pBt->pSchema;
6515}
6516
danielk1977c87d34d2006-01-06 13:00:28 +00006517/*
6518** Return true if another user of the same shared btree as the argument
6519** handle holds an exclusive lock on the sqlite_master table.
6520*/
6521int sqlite3BtreeSchemaLocked(Btree *p){
6522 return (queryTableLock(p, MASTER_ROOT, READ_LOCK)!=SQLITE_OK);
6523}
6524
drha154dcd2006-03-22 22:10:07 +00006525
6526#ifndef SQLITE_OMIT_SHARED_CACHE
6527/*
6528** Obtain a lock on the table whose root page is iTab. The
6529** lock is a write lock if isWritelock is true or a read lock
6530** if it is false.
6531*/
danielk1977c00da102006-01-07 13:21:04 +00006532int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
danielk19772e94d4d2006-01-09 05:36:27 +00006533 int rc = SQLITE_OK;
danielk1977c00da102006-01-07 13:21:04 +00006534 u8 lockType = (isWriteLock?WRITE_LOCK:READ_LOCK);
danielk19772e94d4d2006-01-09 05:36:27 +00006535 rc = queryTableLock(p, iTab, lockType);
danielk1977c00da102006-01-07 13:21:04 +00006536 if( rc==SQLITE_OK ){
6537 rc = lockTable(p, iTab, lockType);
6538 }
6539 return rc;
6540}
drha154dcd2006-03-22 22:10:07 +00006541#endif
danielk1977b82e7ed2006-01-11 14:09:31 +00006542
drh6f7adc82006-01-11 21:41:20 +00006543/*
6544** The following debugging interface has to be in this file (rather
6545** than in, for example, test1.c) so that it can get access to
6546** the definition of BtShared.
6547*/
danielk197707cb5602006-01-20 10:55:05 +00006548#if defined(SQLITE_DEBUG) && defined(TCLSH)
danielk1977b82e7ed2006-01-11 14:09:31 +00006549#include <tcl.h>
6550int sqlite3_shared_cache_report(
6551 void * clientData,
6552 Tcl_Interp *interp,
6553 int objc,
6554 Tcl_Obj *CONST objv[]
6555){
drha154dcd2006-03-22 22:10:07 +00006556#ifndef SQLITE_OMIT_SHARED_CACHE
drh6f7adc82006-01-11 21:41:20 +00006557 const ThreadData *pTd = sqlite3ThreadDataReadOnly();
danielk1977b82e7ed2006-01-11 14:09:31 +00006558 if( pTd->useSharedData ){
6559 BtShared *pBt;
6560 Tcl_Obj *pRet = Tcl_NewObj();
6561 for(pBt=pTd->pBtree; pBt; pBt=pBt->pNext){
6562 const char *zFile = sqlite3pager_filename(pBt->pPager);
6563 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewStringObj(zFile, -1));
6564 Tcl_ListObjAppendElement(interp, pRet, Tcl_NewIntObj(pBt->nRef));
6565 }
6566 Tcl_SetObjResult(interp, pRet);
6567 }
drha154dcd2006-03-22 22:10:07 +00006568#endif
danielk1977b82e7ed2006-01-11 14:09:31 +00006569 return TCL_OK;
6570}
6571#endif