drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 1 | /* |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 2 | ** 2001 September 15 |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 3 | ** |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 4 | ** The author disclaims copyright to this source code. In place of |
| 5 | ** a legal notice, here is a blessing: |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 6 | ** |
drh | b19a2bc | 2001-09-16 00:13:26 +0000 | [diff] [blame] | 7 | ** 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. |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 10 | ** |
| 11 | ************************************************************************* |
| 12 | ** This header file defines the interface that the sqlite B-Tree file |
drh | 6446c4d | 2001-12-15 14:22:18 +0000 | [diff] [blame] | 13 | ** subsystem. See comments in the source code for a detailed description |
| 14 | ** of what each interface routine does. |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 15 | ** |
danielk1977 | c7af484 | 2008-10-27 13:59:33 +0000 | [diff] [blame] | 16 | ** @(#) $Id: btree.h,v 1.105 2008/10/27 13:59:34 danielk1977 Exp $ |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 17 | */ |
drh | be0072d | 2001-09-13 14:46:09 +0000 | [diff] [blame] | 18 | #ifndef _BTREE_H_ |
| 19 | #define _BTREE_H_ |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 20 | |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 21 | /* TODO: This definition is just included so other modules compile. It |
| 22 | ** needs to be revisited. |
| 23 | */ |
| 24 | #define SQLITE_N_BTREE_META 10 |
| 25 | |
drh | 73509ee | 2003-04-06 20:44:45 +0000 | [diff] [blame] | 26 | /* |
danielk1977 | 951af80 | 2004-11-05 15:45:09 +0000 | [diff] [blame] | 27 | ** If defined as non-zero, auto-vacuum is enabled by default. Otherwise |
| 28 | ** it must be turned on for each database using "PRAGMA auto_vacuum = 1". |
| 29 | */ |
| 30 | #ifndef SQLITE_DEFAULT_AUTOVACUUM |
| 31 | #define SQLITE_DEFAULT_AUTOVACUUM 0 |
| 32 | #endif |
| 33 | |
danielk1977 | dddbcdc | 2007-04-26 14:42:34 +0000 | [diff] [blame] | 34 | #define BTREE_AUTOVACUUM_NONE 0 /* Do not do auto-vacuum */ |
| 35 | #define BTREE_AUTOVACUUM_FULL 1 /* Do full auto-vacuum */ |
| 36 | #define BTREE_AUTOVACUUM_INCR 2 /* Incremental vacuum */ |
| 37 | |
danielk1977 | 951af80 | 2004-11-05 15:45:09 +0000 | [diff] [blame] | 38 | /* |
drh | 73509ee | 2003-04-06 20:44:45 +0000 | [diff] [blame] | 39 | ** Forward declarations of structure |
| 40 | */ |
drh | a059ad0 | 2001-04-17 20:09:11 +0000 | [diff] [blame] | 41 | typedef struct Btree Btree; |
| 42 | typedef struct BtCursor BtCursor; |
danielk1977 | aef0bf6 | 2005-12-30 16:28:01 +0000 | [diff] [blame] | 43 | typedef struct BtShared BtShared; |
drh | 4cf7c7f | 2007-08-28 23:28:07 +0000 | [diff] [blame] | 44 | typedef struct BtreeMutexArray BtreeMutexArray; |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 45 | |
| 46 | /* |
| 47 | ** This structure records all of the Btrees that need to hold |
| 48 | ** a mutex before we enter sqlite3VdbeExec(). The Btrees are |
| 49 | ** are placed in aBtree[] in order of aBtree[]->pBt. That way, |
| 50 | ** we can always lock and unlock them all quickly. |
| 51 | */ |
drh | 4cf7c7f | 2007-08-28 23:28:07 +0000 | [diff] [blame] | 52 | struct BtreeMutexArray { |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 53 | int nMutex; |
| 54 | Btree *aBtree[SQLITE_MAX_ATTACHED+1]; |
| 55 | }; |
paul | b95a886 | 2003-04-01 21:16:41 +0000 | [diff] [blame] | 56 | |
drh | 73509ee | 2003-04-06 20:44:45 +0000 | [diff] [blame] | 57 | |
danielk1977 | 24162fe | 2004-06-04 06:22:00 +0000 | [diff] [blame] | 58 | int sqlite3BtreeOpen( |
drh | 90f5ecb | 2004-07-22 01:19:35 +0000 | [diff] [blame] | 59 | const char *zFilename, /* Name of database file to open */ |
danielk1977 | aef0bf6 | 2005-12-30 16:28:01 +0000 | [diff] [blame] | 60 | sqlite3 *db, /* Associated database connection */ |
drh | 90f5ecb | 2004-07-22 01:19:35 +0000 | [diff] [blame] | 61 | Btree **, /* Return open Btree* here */ |
drh | 33f4e02 | 2007-09-03 15:19:34 +0000 | [diff] [blame] | 62 | int flags, /* Flags */ |
| 63 | int vfsFlags /* Flags passed through to VFS open */ |
danielk1977 | 24162fe | 2004-06-04 06:22:00 +0000 | [diff] [blame] | 64 | ); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 65 | |
| 66 | /* The flags parameter to sqlite3BtreeOpen can be the bitwise or of the |
| 67 | ** following values. |
drh | 7bec505 | 2005-02-06 02:45:41 +0000 | [diff] [blame] | 68 | ** |
| 69 | ** NOTE: These values must match the corresponding PAGER_ values in |
| 70 | ** pager.h. |
drh | 73509ee | 2003-04-06 20:44:45 +0000 | [diff] [blame] | 71 | */ |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 72 | #define BTREE_OMIT_JOURNAL 1 /* Do not use journal. No argument */ |
drh | 7bec505 | 2005-02-06 02:45:41 +0000 | [diff] [blame] | 73 | #define BTREE_NO_READLOCK 2 /* Omit readlocks on readonly files */ |
| 74 | #define BTREE_MEMORY 4 /* In-memory DB. No argument */ |
drh | e53831d | 2007-08-17 01:14:38 +0000 | [diff] [blame] | 75 | #define BTREE_READONLY 8 /* Open the database in read-only mode */ |
| 76 | #define BTREE_READWRITE 16 /* Open for both reading and writing */ |
| 77 | #define BTREE_CREATE 32 /* Create the database if it does not exist */ |
| 78 | |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 79 | int sqlite3BtreeClose(Btree*); |
| 80 | int sqlite3BtreeSetCacheSize(Btree*,int); |
drh | ac530b1 | 2006-02-11 01:25:50 +0000 | [diff] [blame] | 81 | int sqlite3BtreeSetSafetyLevel(Btree*,int,int); |
drh | 2c8997b | 2005-08-27 16:36:48 +0000 | [diff] [blame] | 82 | int sqlite3BtreeSyncDisabled(Btree*); |
drh | 90f5ecb | 2004-07-22 01:19:35 +0000 | [diff] [blame] | 83 | int sqlite3BtreeSetPageSize(Btree*,int,int); |
| 84 | int sqlite3BtreeGetPageSize(Btree*); |
drh | f8e632b | 2007-05-08 14:51:36 +0000 | [diff] [blame] | 85 | int sqlite3BtreeMaxPageCount(Btree*,int); |
drh | 2011d5f | 2004-07-22 02:40:37 +0000 | [diff] [blame] | 86 | int sqlite3BtreeGetReserve(Btree*); |
danielk1977 | 951af80 | 2004-11-05 15:45:09 +0000 | [diff] [blame] | 87 | int sqlite3BtreeSetAutoVacuum(Btree *, int); |
| 88 | int sqlite3BtreeGetAutoVacuum(Btree *); |
danielk1977 | 40b38dc | 2004-06-26 08:38:24 +0000 | [diff] [blame] | 89 | int sqlite3BtreeBeginTrans(Btree*,int); |
drh | 80e35f4 | 2007-03-30 14:06:34 +0000 | [diff] [blame] | 90 | int sqlite3BtreeCommitPhaseOne(Btree*, const char *zMaster); |
| 91 | int sqlite3BtreeCommitPhaseTwo(Btree*); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 92 | int sqlite3BtreeCommit(Btree*); |
| 93 | int sqlite3BtreeRollback(Btree*); |
| 94 | int sqlite3BtreeBeginStmt(Btree*); |
| 95 | int sqlite3BtreeCommitStmt(Btree*); |
| 96 | int sqlite3BtreeRollbackStmt(Btree*); |
| 97 | int sqlite3BtreeCreateTable(Btree*, int*, int flags); |
danielk1977 | 1d850a7 | 2004-05-31 08:26:49 +0000 | [diff] [blame] | 98 | int sqlite3BtreeIsInTrans(Btree*); |
| 99 | int sqlite3BtreeIsInStmt(Btree*); |
danielk1977 | 2372c2b | 2006-06-27 16:34:56 +0000 | [diff] [blame] | 100 | int sqlite3BtreeIsInReadTrans(Btree*); |
danielk1977 | da18423 | 2006-01-05 11:34:32 +0000 | [diff] [blame] | 101 | void *sqlite3BtreeSchema(Btree *, int, void(*)(void *)); |
danielk1977 | c87d34d | 2006-01-06 13:00:28 +0000 | [diff] [blame] | 102 | int sqlite3BtreeSchemaLocked(Btree *); |
danielk1977 | c00da10 | 2006-01-07 13:21:04 +0000 | [diff] [blame] | 103 | int sqlite3BtreeLockTable(Btree *, int, u8); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 104 | |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 105 | const char *sqlite3BtreeGetFilename(Btree *); |
danielk1977 | 5865e3d | 2004-06-14 06:03:57 +0000 | [diff] [blame] | 106 | const char *sqlite3BtreeGetDirname(Btree *); |
| 107 | const char *sqlite3BtreeGetJournalname(Btree *); |
danielk1977 | 4adee20 | 2004-05-08 08:23:19 +0000 | [diff] [blame] | 108 | int sqlite3BtreeCopyFile(Btree *, Btree *); |
| 109 | |
danielk1977 | dddbcdc | 2007-04-26 14:42:34 +0000 | [diff] [blame] | 110 | int sqlite3BtreeIncrVacuum(Btree *); |
| 111 | |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 112 | /* The flags parameter to sqlite3BtreeCreateTable can be the bitwise OR |
| 113 | ** of the following flags: |
drh | 73509ee | 2003-04-06 20:44:45 +0000 | [diff] [blame] | 114 | */ |
drh | 8b18dd4 | 2004-05-12 19:18:15 +0000 | [diff] [blame] | 115 | #define BTREE_INTKEY 1 /* Table has only 64-bit signed integer keys */ |
| 116 | #define BTREE_ZERODATA 2 /* Table has keys only - no data */ |
| 117 | #define BTREE_LEAFDATA 4 /* Data stored in leaves only. Implies INTKEY */ |
drh | 73509ee | 2003-04-06 20:44:45 +0000 | [diff] [blame] | 118 | |
danielk1977 | a0bf265 | 2004-11-04 14:30:04 +0000 | [diff] [blame] | 119 | int sqlite3BtreeDropTable(Btree*, int, int*); |
danielk1977 | c7af484 | 2008-10-27 13:59:33 +0000 | [diff] [blame] | 120 | int sqlite3BtreeClearTable(Btree*, int, int*); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 121 | int sqlite3BtreeGetMeta(Btree*, int idx, u32 *pValue); |
| 122 | int sqlite3BtreeUpdateMeta(Btree*, int idx, u32 value); |
drh | fb98264 | 2007-08-30 01:19:59 +0000 | [diff] [blame] | 123 | void sqlite3BtreeTripAllCursors(Btree*, int); |
paul | b95a886 | 2003-04-01 21:16:41 +0000 | [diff] [blame] | 124 | |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 125 | int sqlite3BtreeCursor( |
danielk1977 | cd3e8f7 | 2008-03-25 09:47:35 +0000 | [diff] [blame] | 126 | Btree*, /* BTree containing table to open */ |
| 127 | int iTable, /* Index of root page */ |
| 128 | int wrFlag, /* 1 for writing. 0 for read-only */ |
| 129 | struct KeyInfo*, /* First argument to compare function */ |
| 130 | BtCursor *pCursor /* Space to write cursor structure */ |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 131 | ); |
drh | 59020f3 | 2008-04-26 13:39:46 +0000 | [diff] [blame] | 132 | int sqlite3BtreeCursorSize(void); |
paul | b95a886 | 2003-04-01 21:16:41 +0000 | [diff] [blame] | 133 | |
drh | a34b676 | 2004-05-07 13:30:42 +0000 | [diff] [blame] | 134 | int sqlite3BtreeCloseCursor(BtCursor*); |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 135 | int sqlite3BtreeMoveto( |
| 136 | BtCursor*, |
| 137 | const void *pKey, |
drh | e14006d | 2008-03-25 17:23:32 +0000 | [diff] [blame] | 138 | i64 nKey, |
| 139 | int bias, |
| 140 | int *pRes |
| 141 | ); |
drh | e63d999 | 2008-08-13 19:11:48 +0000 | [diff] [blame] | 142 | int sqlite3BtreeMovetoUnpacked( |
| 143 | BtCursor*, |
| 144 | UnpackedRecord *pUnKey, |
| 145 | i64 intKey, |
| 146 | int bias, |
| 147 | int *pRes |
| 148 | ); |
drh | a346058 | 2008-07-11 21:02:53 +0000 | [diff] [blame] | 149 | int sqlite3BtreeCursorHasMoved(BtCursor*, int*); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 150 | int sqlite3BtreeDelete(BtCursor*); |
drh | 4a1c380 | 2004-05-12 15:15:47 +0000 | [diff] [blame] | 151 | int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey, |
drh | b026e05 | 2007-05-02 01:34:31 +0000 | [diff] [blame] | 152 | const void *pData, int nData, |
| 153 | int nZero, int bias); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 154 | int sqlite3BtreeFirst(BtCursor*, int *pRes); |
| 155 | int sqlite3BtreeLast(BtCursor*, int *pRes); |
| 156 | int sqlite3BtreeNext(BtCursor*, int *pRes); |
drh | c39e000 | 2004-05-07 23:50:57 +0000 | [diff] [blame] | 157 | int sqlite3BtreeEof(BtCursor*); |
drh | f328bc8 | 2004-05-10 23:29:49 +0000 | [diff] [blame] | 158 | int sqlite3BtreeFlags(BtCursor*); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 159 | int sqlite3BtreePrevious(BtCursor*, int *pRes); |
drh | 4a1c380 | 2004-05-12 15:15:47 +0000 | [diff] [blame] | 160 | int sqlite3BtreeKeySize(BtCursor*, i64 *pSize); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 161 | int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*); |
drh | b21c8cd | 2007-08-21 19:33:56 +0000 | [diff] [blame] | 162 | sqlite3 *sqlite3BtreeCursorDb(const BtCursor*); |
drh | e51c44f | 2004-05-30 20:46:09 +0000 | [diff] [blame] | 163 | const void *sqlite3BtreeKeyFetch(BtCursor*, int *pAmt); |
| 164 | const void *sqlite3BtreeDataFetch(BtCursor*, int *pAmt); |
drh | 3aac2dd | 2004-04-26 14:10:20 +0000 | [diff] [blame] | 165 | int sqlite3BtreeDataSize(BtCursor*, u32 *pSize); |
| 166 | int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt, void*); |
drh | 144f9ea | 2003-04-16 01:28:16 +0000 | [diff] [blame] | 167 | |
drh | 1dcdbc0 | 2007-01-27 02:24:54 +0000 | [diff] [blame] | 168 | char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot, int, int*); |
drh | a34b676 | 2004-05-07 13:30:42 +0000 | [diff] [blame] | 169 | struct Pager *sqlite3BtreePager(Btree*); |
| 170 | |
danielk1977 | dcbb5d3 | 2007-05-04 18:36:44 +0000 | [diff] [blame] | 171 | int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*); |
danielk1977 | 2dec970 | 2007-05-02 16:48:37 +0000 | [diff] [blame] | 172 | void sqlite3BtreeCacheOverflow(BtCursor *); |
danielk1977 | be51a65 | 2008-10-08 17:58:48 +0000 | [diff] [blame] | 173 | void sqlite3BtreeClearCursor(BtCursor *); |
drh | f328bc8 | 2004-05-10 23:29:49 +0000 | [diff] [blame] | 174 | |
drh | a34b676 | 2004-05-07 13:30:42 +0000 | [diff] [blame] | 175 | #ifdef SQLITE_TEST |
drh | 3e27c02 | 2004-07-23 00:01:38 +0000 | [diff] [blame] | 176 | int sqlite3BtreeCursorInfo(BtCursor*, int*, int); |
drh | c8629a1 | 2004-05-08 20:07:40 +0000 | [diff] [blame] | 177 | void sqlite3BtreeCursorList(Btree*); |
danielk1977 | b5402fb | 2005-01-12 07:15:04 +0000 | [diff] [blame] | 178 | #endif |
drh | be0072d | 2001-09-13 14:46:09 +0000 | [diff] [blame] | 179 | |
drh | b1ab8ea | 2007-08-29 00:33:07 +0000 | [diff] [blame] | 180 | /* |
| 181 | ** If we are not using shared cache, then there is no need to |
| 182 | ** use mutexes to access the BtShared structures. So make the |
| 183 | ** Enter and Leave procedures no-ops. |
| 184 | */ |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 185 | #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE |
drh | b1ab8ea | 2007-08-29 00:33:07 +0000 | [diff] [blame] | 186 | void sqlite3BtreeEnter(Btree*); |
| 187 | void sqlite3BtreeLeave(Btree*); |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 188 | #ifndef NDEBUG |
| 189 | /* This routine is used inside assert() statements only. */ |
drh | 1fee73e | 2007-08-29 04:00:57 +0000 | [diff] [blame] | 190 | int sqlite3BtreeHoldsMutex(Btree*); |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 191 | #endif |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 192 | void sqlite3BtreeEnterCursor(BtCursor*); |
| 193 | void sqlite3BtreeLeaveCursor(BtCursor*); |
drh | b1ab8ea | 2007-08-29 00:33:07 +0000 | [diff] [blame] | 194 | void sqlite3BtreeEnterAll(sqlite3*); |
| 195 | void sqlite3BtreeLeaveAll(sqlite3*); |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 196 | #ifndef NDEBUG |
| 197 | /* This routine is used inside assert() statements only. */ |
drh | 1fee73e | 2007-08-29 04:00:57 +0000 | [diff] [blame] | 198 | int sqlite3BtreeHoldsAllMutexes(sqlite3*); |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 199 | #endif |
drh | 4cf7c7f | 2007-08-28 23:28:07 +0000 | [diff] [blame] | 200 | void sqlite3BtreeMutexArrayEnter(BtreeMutexArray*); |
| 201 | void sqlite3BtreeMutexArrayLeave(BtreeMutexArray*); |
| 202 | void sqlite3BtreeMutexArrayInsert(BtreeMutexArray*, Btree*); |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 203 | #else |
drh | b1ab8ea | 2007-08-29 00:33:07 +0000 | [diff] [blame] | 204 | # define sqlite3BtreeEnter(X) |
| 205 | # define sqlite3BtreeLeave(X) |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 206 | #ifndef NDEBUG |
| 207 | /* This routine is used inside assert() statements only. */ |
drh | 1fee73e | 2007-08-29 04:00:57 +0000 | [diff] [blame] | 208 | # define sqlite3BtreeHoldsMutex(X) 1 |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 209 | #endif |
drh | ff0587c | 2007-08-29 17:43:19 +0000 | [diff] [blame] | 210 | # define sqlite3BtreeEnterCursor(X) |
| 211 | # define sqlite3BtreeLeaveCursor(X) |
drh | b1ab8ea | 2007-08-29 00:33:07 +0000 | [diff] [blame] | 212 | # define sqlite3BtreeEnterAll(X) |
| 213 | # define sqlite3BtreeLeaveAll(X) |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 214 | #ifndef NDEBUG |
| 215 | /* This routine is used inside assert() statements only. */ |
drh | 1fee73e | 2007-08-29 04:00:57 +0000 | [diff] [blame] | 216 | # define sqlite3BtreeHoldsAllMutexes(X) 1 |
shane | a6f6d20 | 2008-05-29 03:01:23 +0000 | [diff] [blame] | 217 | #endif |
drh | 4cf7c7f | 2007-08-28 23:28:07 +0000 | [diff] [blame] | 218 | # define sqlite3BtreeMutexArrayEnter(X) |
| 219 | # define sqlite3BtreeMutexArrayLeave(X) |
| 220 | # define sqlite3BtreeMutexArrayInsert(X,Y) |
drh | 900b31e | 2007-08-28 02:27:51 +0000 | [diff] [blame] | 221 | #endif |
| 222 | |
| 223 | |
drh | be0072d | 2001-09-13 14:46:09 +0000 | [diff] [blame] | 224 | #endif /* _BTREE_H_ */ |