Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / vdbeInt.h
blobbb504d64a1f282be0ee3685164139941d4df612c
1 /*
2 ** 2003 September 6
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
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.
11 *************************************************************************
12 ** This is the header file for information that is private to the
13 ** VDBE. This information used to all be at the top of the single
14 ** source code file "vdbe.c". When that file became too big (over
15 ** 6000 lines long) it was split up into several smaller files and
16 ** this header information was factored out.
18 #ifndef _VDBEINT_H_
19 #define _VDBEINT_H_
22 ** The maximum number of times that a statement will try to reparse
23 ** itself before giving up and returning SQLITE_SCHEMA.
25 #ifndef SQLITE_MAX_SCHEMA_RETRY
26 # define SQLITE_MAX_SCHEMA_RETRY 50
27 #endif
30 ** SQL is translated into a sequence of instructions to be
31 ** executed by a virtual machine. Each instruction is an instance
32 ** of the following structure.
34 typedef struct VdbeOp Op;
37 ** Boolean values
39 typedef unsigned Bool;
41 /* Opaque type used by code in vdbesort.c */
42 typedef struct VdbeSorter VdbeSorter;
44 /* Opaque type used by the explainer */
45 typedef struct Explain Explain;
47 /* Elements of the linked list at Vdbe.pAuxData */
48 typedef struct AuxData AuxData;
51 ** A cursor is a pointer into a single BTree within a database file.
52 ** The cursor can seek to a BTree entry with a particular key, or
53 ** loop over all entries of the Btree. You can also insert new BTree
54 ** entries or retrieve the key or data from the entry that the cursor
55 ** is currently pointing to.
57 ** Cursors can also point to virtual tables, sorters, or "pseudo-tables".
58 ** A pseudo-table is a single-row table implemented by registers.
59 **
60 ** Every cursor that the virtual machine has open is represented by an
61 ** instance of the following structure.
63 struct VdbeCursor {
64 BtCursor *pCursor; /* The cursor structure of the backend */
65 Btree *pBt; /* Separate file holding temporary table */
66 KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
67 int seekResult; /* Result of previous sqlite3BtreeMoveto() */
68 int pseudoTableReg; /* Register holding pseudotable content. */
69 i16 nField; /* Number of fields in the header */
70 u16 nHdrParsed; /* Number of header fields parsed so far */
71 #ifdef SQLITE_DEBUG
72 u8 seekOp; /* Most recent seek operation on this cursor */
73 #endif
74 i8 iDb; /* Index of cursor database in db->aDb[] (or -1) */
75 u8 nullRow; /* True if pointing to a row with no data */
76 u8 deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */
77 Bool isEphemeral:1; /* True for an ephemeral table */
78 Bool useRandomRowid:1;/* Generate new record numbers semi-randomly */
79 Bool isTable:1; /* True if a table requiring integer keys */
80 Bool isOrdered:1; /* True if the underlying table is BTREE_UNORDERED */
81 Pgno pgnoRoot; /* Root page of the open btree cursor */
82 sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */
83 i64 seqCount; /* Sequence counter */
84 i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */
85 VdbeSorter *pSorter; /* Sorter object for OP_SorterOpen cursors */
87 /* Cached information about the header for the data record that the
88 ** cursor is currently pointing to. Only valid if cacheStatus matches
89 ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
90 ** CACHE_STALE and so setting cacheStatus=CACHE_STALE guarantees that
91 ** the cache is out of date.
93 ** aRow might point to (ephemeral) data for the current row, or it might
94 ** be NULL.
96 u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
97 u32 payloadSize; /* Total number of bytes in the record */
98 u32 szRow; /* Byte available in aRow */
99 u32 iHdrOffset; /* Offset to next unparsed byte of the header */
100 const u8 *aRow; /* Data for the current row, if all on one page */
101 u32 *aOffset; /* Pointer to aType[nField] */
102 u32 aType[1]; /* Type values for all entries in the record */
103 /* 2*nField extra array elements allocated for aType[], beyond the one
104 ** static element declared in the structure. nField total array slots for
105 ** aType[] and nField+1 array slots for aOffset[] */
107 typedef struct VdbeCursor VdbeCursor;
110 ** When a sub-program is executed (OP_Program), a structure of this type
111 ** is allocated to store the current value of the program counter, as
112 ** well as the current memory cell array and various other frame specific
113 ** values stored in the Vdbe struct. When the sub-program is finished,
114 ** these values are copied back to the Vdbe from the VdbeFrame structure,
115 ** restoring the state of the VM to as it was before the sub-program
116 ** began executing.
118 ** The memory for a VdbeFrame object is allocated and managed by a memory
119 ** cell in the parent (calling) frame. When the memory cell is deleted or
120 ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
121 ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
122 ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
123 ** this instead of deleting the VdbeFrame immediately is to avoid recursive
124 ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
125 ** child frame are released.
127 ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
128 ** set to NULL if the currently executing frame is the main program.
130 typedef struct VdbeFrame VdbeFrame;
131 struct VdbeFrame {
132 Vdbe *v; /* VM this frame belongs to */
133 VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */
134 Op *aOp; /* Program instructions for parent frame */
135 Mem *aMem; /* Array of memory cells for parent frame */
136 u8 *aOnceFlag; /* Array of OP_Once flags for parent frame */
137 VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
138 void *token; /* Copy of SubProgram.token */
139 i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */
140 int nCursor; /* Number of entries in apCsr */
141 int pc; /* Program Counter in parent (calling) frame */
142 int nOp; /* Size of aOp array */
143 int nMem; /* Number of entries in aMem */
144 int nOnceFlag; /* Number of entries in aOnceFlag */
145 int nChildMem; /* Number of memory cells for child frame */
146 int nChildCsr; /* Number of cursors for child frame */
147 int nChange; /* Statement changes (Vdbe.nChanges) */
150 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
153 ** A value for VdbeCursor.cacheValid that means the cache is always invalid.
155 #define CACHE_STALE 0
158 ** Internally, the vdbe manipulates nearly all SQL values as Mem
159 ** structures. Each Mem struct may cache multiple representations (string,
160 ** integer etc.) of the same value.
162 struct Mem {
163 union MemValue {
164 double r; /* Real value used when MEM_Real is set in flags */
165 i64 i; /* Integer value used when MEM_Int is set in flags */
166 int nZero; /* Used when bit MEM_Zero is set in flags */
167 FuncDef *pDef; /* Used only when flags==MEM_Agg */
168 RowSet *pRowSet; /* Used only when flags==MEM_RowSet */
169 VdbeFrame *pFrame; /* Used when flags==MEM_Frame */
170 } u;
171 u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
172 u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
173 int n; /* Number of characters in string value, excluding '\0' */
174 char *z; /* String or BLOB value */
175 /* ShallowCopy only needs to copy the information above */
176 char *zMalloc; /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */
177 int szMalloc; /* Size of the zMalloc allocation */
178 u32 uTemp; /* Transient storage for serial_type in OP_MakeRecord */
179 sqlite3 *db; /* The associated database connection */
180 void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
181 #ifdef SQLITE_DEBUG
182 Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
183 void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
184 #endif
187 /* One or more of the following flags are set to indicate the validOK
188 ** representations of the value stored in the Mem struct.
190 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
191 ** No other flags may be set in this case.
193 ** If the MEM_Str flag is set then Mem.z points at a string representation.
194 ** Usually this is encoded in the same unicode encoding as the main
195 ** database (see below for exceptions). If the MEM_Term flag is also
196 ** set, then the string is nul terminated. The MEM_Int and MEM_Real
197 ** flags may coexist with the MEM_Str flag.
199 #define MEM_Null 0x0001 /* Value is NULL */
200 #define MEM_Str 0x0002 /* Value is a string */
201 #define MEM_Int 0x0004 /* Value is an integer */
202 #define MEM_Real 0x0008 /* Value is a real number */
203 #define MEM_Blob 0x0010 /* Value is a BLOB */
204 #define MEM_AffMask 0x001f /* Mask of affinity bits */
205 #define MEM_RowSet 0x0020 /* Value is a RowSet object */
206 #define MEM_Frame 0x0040 /* Value is a VdbeFrame object */
207 #define MEM_Undefined 0x0080 /* Value is undefined */
208 #define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */
209 #define MEM_TypeMask 0x01ff /* Mask of type bits */
212 /* Whenever Mem contains a valid string or blob representation, one of
213 ** the following flags must be set to determine the memory management
214 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
215 ** string is \000 or \u0000 terminated
217 #define MEM_Term 0x0200 /* String rep is nul terminated */
218 #define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */
219 #define MEM_Static 0x0800 /* Mem.z points to a static string */
220 #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
221 #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
222 #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
223 #ifdef SQLITE_OMIT_INCRBLOB
224 #undef MEM_Zero
225 #define MEM_Zero 0x0000
226 #endif
229 ** Clear any existing type flags from a Mem and replace them with f
231 #define MemSetTypeFlag(p, f) \
232 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
235 ** Return true if a memory cell is not marked as invalid. This macro
236 ** is for use inside assert() statements only.
238 #ifdef SQLITE_DEBUG
239 #define memIsValid(M) ((M)->flags & MEM_Undefined)==0
240 #endif
243 ** Each auxiliary data pointer stored by a user defined function
244 ** implementation calling sqlite3_set_auxdata() is stored in an instance
245 ** of this structure. All such structures associated with a single VM
246 ** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed
247 ** when the VM is halted (if not before).
249 struct AuxData {
250 int iOp; /* Instruction number of OP_Function opcode */
251 int iArg; /* Index of function argument. */
252 void *pAux; /* Aux data pointer */
253 void (*xDelete)(void *); /* Destructor for the aux data */
254 AuxData *pNext; /* Next element in list */
258 ** The "context" argument for an installable function. A pointer to an
259 ** instance of this structure is the first argument to the routines used
260 ** implement the SQL functions.
262 ** There is a typedef for this structure in sqlite.h. So all routines,
263 ** even the public interface to SQLite, can use a pointer to this structure.
264 ** But this file is the only place where the internal details of this
265 ** structure are known.
267 ** This structure is defined inside of vdbeInt.h because it uses substructures
268 ** (Mem) which are only defined there.
270 struct sqlite3_context {
271 Mem *pOut; /* The return value is stored here */
272 FuncDef *pFunc; /* Pointer to function information */
273 Mem *pMem; /* Memory cell used to store aggregate context */
274 Vdbe *pVdbe; /* The VM that owns this context */
275 int iOp; /* Instruction number of OP_Function */
276 int isError; /* Error code returned by the function. */
277 u8 skipFlag; /* Skip accumulator loading if true */
278 u8 fErrorOrAux; /* isError!=0 or pVdbe->pAuxData modified */
282 ** An Explain object accumulates indented output which is helpful
283 ** in describing recursive data structures.
285 struct Explain {
286 Vdbe *pVdbe; /* Attach the explanation to this Vdbe */
287 StrAccum str; /* The string being accumulated */
288 int nIndent; /* Number of elements in aIndent */
289 u16 aIndent[100]; /* Levels of indentation */
290 char zBase[100]; /* Initial space */
293 /* A bitfield type for use inside of structures. Always follow with :N where
294 ** N is the number of bits.
296 typedef unsigned bft; /* Bit Field Type */
299 ** An instance of the virtual machine. This structure contains the complete
300 ** state of the virtual machine.
302 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
303 ** is really a pointer to an instance of this structure.
305 ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
306 ** any virtual table method invocations made by the vdbe program. It is
307 ** set to 2 for xDestroy method calls and 1 for all other methods. This
308 ** variable is used for two purposes: to allow xDestroy methods to execute
309 ** "DROP TABLE" statements and to prevent some nasty side effects of
310 ** malloc failure when SQLite is invoked recursively by a virtual table
311 ** method function.
313 struct Vdbe {
314 sqlite3 *db; /* The database connection that owns this statement */
315 Op *aOp; /* Space to hold the virtual machine's program */
316 Mem *aMem; /* The memory locations */
317 Mem **apArg; /* Arguments to currently executing user function */
318 Mem *aColName; /* Column names to return */
319 Mem *pResultSet; /* Pointer to an array of results */
320 Parse *pParse; /* Parsing context used to create this Vdbe */
321 int nMem; /* Number of memory locations currently allocated */
322 int nOp; /* Number of instructions in the program */
323 int nCursor; /* Number of slots in apCsr[] */
324 u32 magic; /* Magic number for sanity checking */
325 char *zErrMsg; /* Error message written here */
326 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
327 VdbeCursor **apCsr; /* One element of this array for each open cursor */
328 Mem *aVar; /* Values for the OP_Variable opcode. */
329 char **azVar; /* Name of variables */
330 ynVar nVar; /* Number of entries in aVar[] */
331 ynVar nzVar; /* Number of entries in azVar[] */
332 u32 cacheCtr; /* VdbeCursor row cache generation counter */
333 int pc; /* The program counter */
334 int rc; /* Value to return */
335 u16 nResColumn; /* Number of columns in one row of the result set */
336 u8 errorAction; /* Recovery action to do in case of an error */
337 u8 minWriteFileFormat; /* Minimum file format for writable database files */
338 bft explain:2; /* True if EXPLAIN present on SQL command */
339 bft inVtabMethod:2; /* See comments above */
340 bft changeCntOn:1; /* True to update the change-counter */
341 bft expired:1; /* True if the VM needs to be recompiled */
342 bft runOnlyOnce:1; /* Automatically expire on reset */
343 bft usesStmtJournal:1; /* True if uses a statement journal */
344 bft readOnly:1; /* True for statements that do not write */
345 bft bIsReader:1; /* True for statements that read */
346 bft isPrepareV2:1; /* True if prepared with prepare_v2() */
347 bft doingRerun:1; /* True if rerunning after an auto-reprepare */
348 int nChange; /* Number of db changes made since last reset */
349 yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
350 yDbMask lockMask; /* Subset of btreeMask that requires a lock */
351 int iStatement; /* Statement number (or 0 if has not opened stmt) */
352 u32 aCounter[5]; /* Counters used by sqlite3_stmt_status() */
353 #ifndef SQLITE_OMIT_TRACE
354 i64 startTime; /* Time when query started - used for profiling */
355 #endif
356 i64 iCurrentTime; /* Value of julianday('now') for this statement */
357 i64 nFkConstraint; /* Number of imm. FK constraints this VM */
358 i64 nStmtDefCons; /* Number of def. constraints when stmt started */
359 i64 nStmtDefImmCons; /* Number of def. imm constraints when stmt started */
360 char *zSql; /* Text of the SQL statement that generated this */
361 void *pFree; /* Free this when deleting the vdbe */
362 VdbeFrame *pFrame; /* Parent frame */
363 VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */
364 int nFrame; /* Number of frames in pFrame list */
365 u32 expmask; /* Binding to these vars invalidates VM */
366 SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
367 int nOnceFlag; /* Size of array aOnceFlag[] */
368 u8 *aOnceFlag; /* Flags for OP_Once */
369 AuxData *pAuxData; /* Linked list of auxdata allocations */
373 ** The following are allowed values for Vdbe.magic
375 #define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */
376 #define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */
377 #define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */
378 #define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */
381 ** Function prototypes
383 void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
384 void sqliteVdbePopStack(Vdbe*,int);
385 int sqlite3VdbeCursorMoveto(VdbeCursor*);
386 int sqlite3VdbeCursorRestore(VdbeCursor*);
387 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
388 void sqlite3VdbePrintOp(FILE*, int, Op*);
389 #endif
390 u32 sqlite3VdbeSerialTypeLen(u32);
391 u32 sqlite3VdbeSerialType(Mem*, int);
392 u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32);
393 u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
394 void sqlite3VdbeDeleteAuxData(Vdbe*, int, int);
396 int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
397 int sqlite3VdbeIdxKeyCompare(sqlite3*,VdbeCursor*,UnpackedRecord*,int*);
398 int sqlite3VdbeIdxRowid(sqlite3*, BtCursor*, i64*);
399 int sqlite3VdbeExec(Vdbe*);
400 int sqlite3VdbeList(Vdbe*);
401 int sqlite3VdbeHalt(Vdbe*);
402 int sqlite3VdbeChangeEncoding(Mem *, int);
403 int sqlite3VdbeMemTooBig(Mem*);
404 int sqlite3VdbeMemCopy(Mem*, const Mem*);
405 void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
406 void sqlite3VdbeMemMove(Mem*, Mem*);
407 int sqlite3VdbeMemNulTerminate(Mem*);
408 int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
409 void sqlite3VdbeMemSetInt64(Mem*, i64);
410 #ifdef SQLITE_OMIT_FLOATING_POINT
411 # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
412 #else
413 void sqlite3VdbeMemSetDouble(Mem*, double);
414 #endif
415 void sqlite3VdbeMemInit(Mem*,sqlite3*,u16);
416 void sqlite3VdbeMemSetNull(Mem*);
417 void sqlite3VdbeMemSetZeroBlob(Mem*,int);
418 void sqlite3VdbeMemSetRowSet(Mem*);
419 int sqlite3VdbeMemMakeWriteable(Mem*);
420 int sqlite3VdbeMemStringify(Mem*, u8, u8);
421 i64 sqlite3VdbeIntValue(Mem*);
422 int sqlite3VdbeMemIntegerify(Mem*);
423 double sqlite3VdbeRealValue(Mem*);
424 void sqlite3VdbeIntegerAffinity(Mem*);
425 int sqlite3VdbeMemRealify(Mem*);
426 int sqlite3VdbeMemNumerify(Mem*);
427 void sqlite3VdbeMemCast(Mem*,u8,u8);
428 int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*);
429 void sqlite3VdbeMemRelease(Mem *p);
430 #define VdbeMemDynamic(X) \
431 (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)
432 int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
433 const char *sqlite3OpcodeName(int);
434 int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
435 int sqlite3VdbeMemClearAndResize(Mem *pMem, int n);
436 int sqlite3VdbeCloseStatement(Vdbe *, int);
437 void sqlite3VdbeFrameDelete(VdbeFrame*);
438 int sqlite3VdbeFrameRestore(VdbeFrame *);
439 int sqlite3VdbeTransferError(Vdbe *p);
441 int sqlite3VdbeSorterInit(sqlite3 *, int, VdbeCursor *);
442 void sqlite3VdbeSorterReset(sqlite3 *, VdbeSorter *);
443 void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *);
444 int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *);
445 int sqlite3VdbeSorterNext(sqlite3 *, const VdbeCursor *, int *);
446 int sqlite3VdbeSorterRewind(const VdbeCursor *, int *);
447 int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);
448 int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);
450 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
451 void sqlite3VdbeEnter(Vdbe*);
452 void sqlite3VdbeLeave(Vdbe*);
453 #else
454 # define sqlite3VdbeEnter(X)
455 # define sqlite3VdbeLeave(X)
456 #endif
458 #ifdef SQLITE_DEBUG
459 void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
460 int sqlite3VdbeCheckMemInvariants(Mem*);
461 #endif
463 #ifndef SQLITE_OMIT_FOREIGN_KEY
464 int sqlite3VdbeCheckFk(Vdbe *, int);
465 #else
466 # define sqlite3VdbeCheckFk(p,i) 0
467 #endif
469 int sqlite3VdbeMemTranslate(Mem*, u8);
470 #ifdef SQLITE_DEBUG
471 void sqlite3VdbePrintSql(Vdbe*);
472 void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
473 #endif
474 int sqlite3VdbeMemHandleBom(Mem *pMem);
476 #ifndef SQLITE_OMIT_INCRBLOB
477 int sqlite3VdbeMemExpandBlob(Mem *);
478 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
479 #else
480 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
481 #define ExpandBlob(P) SQLITE_OK
482 #endif
484 #endif /* !defined(_VDBEINT_H_) */