4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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 SQLITE_VDBEINT_H
19 #define SQLITE_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
30 ** VDBE_DISPLAY_P4 is true or false depending on whether or not the
31 ** "explain" P4 display logic is enabled.
33 #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \
34 || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) \
35 || defined(SQLITE_ENABLE_BYTECODE_VTAB)
36 # define VDBE_DISPLAY_P4 1
38 # define VDBE_DISPLAY_P4 0
42 ** SQL is translated into a sequence of instructions to be
43 ** executed by a virtual machine. Each instruction is an instance
44 ** of the following structure.
46 typedef struct VdbeOp Op
;
51 typedef unsigned Bool
;
53 /* Opaque type used by code in vdbesort.c */
54 typedef struct VdbeSorter VdbeSorter
;
56 /* Elements of the linked list at Vdbe.pAuxData */
57 typedef struct AuxData AuxData
;
59 /* Types of VDBE cursors */
60 #define CURTYPE_BTREE 0
61 #define CURTYPE_SORTER 1
62 #define CURTYPE_VTAB 2
63 #define CURTYPE_PSEUDO 3
66 ** A VdbeCursor is an superclass (a wrapper) for various cursor objects:
69 ** - In the main database or in an ephemeral database
70 ** - On either an index or a table
73 ** * A one-row "pseudotable" stored in a single register
75 typedef struct VdbeCursor VdbeCursor
;
77 u8 eCurType
; /* One of the CURTYPE_* values above */
78 i8 iDb
; /* Index of cursor database in db->aDb[] (or -1) */
79 u8 nullRow
; /* True if pointing to a row with no data */
80 u8 deferredMoveto
; /* A call to sqlite3BtreeMoveto() is needed */
81 u8 isTable
; /* True for rowid tables. False for indexes */
83 u8 seekOp
; /* Most recent seek operation on this cursor */
84 u8 wrFlag
; /* The wrFlag argument to sqlite3BtreeCursor() */
86 Bool isEphemeral
:1; /* True for an ephemeral table */
87 Bool useRandomRowid
:1; /* Generate new record numbers semi-randomly */
88 Bool isOrdered
:1; /* True if the table is not BTREE_UNORDERED */
89 Bool seekHit
:1; /* See the OP_SeekHit and OP_IfNoHope opcodes */
90 Btree
*pBtx
; /* Separate file holding temporary table */
91 i64 seqCount
; /* Sequence counter */
92 u32
*aAltMap
; /* Mapping from table to index column numbers */
94 /* Cached OP_Column parse information is only valid if cacheStatus matches
95 ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
96 ** CACHE_STALE (0) and so setting cacheStatus=CACHE_STALE guarantees that
97 ** the cache is out of date. */
98 u32 cacheStatus
; /* Cache is valid if this matches Vdbe.cacheCtr */
99 int seekResult
; /* Result of previous sqlite3BtreeMoveto() or 0
100 ** if there have been no prior seeks on the cursor. */
101 /* seekResult does not distinguish between "no seeks have ever occurred
102 ** on this cursor" and "the most recent seek was an exact match".
103 ** For CURTYPE_PSEUDO, seekResult is the register holding the record */
105 /* When a new VdbeCursor is allocated, only the fields above are zeroed.
106 ** The fields that follow are uninitialized, and must be individually
107 ** initialized prior to first use. */
108 VdbeCursor
*pAltCursor
; /* Associated index cursor from which to read */
110 BtCursor
*pCursor
; /* CURTYPE_BTREE or _PSEUDO. Btree cursor */
111 sqlite3_vtab_cursor
*pVCur
; /* CURTYPE_VTAB. Vtab cursor */
112 VdbeSorter
*pSorter
; /* CURTYPE_SORTER. Sorter object */
114 KeyInfo
*pKeyInfo
; /* Info about index keys needed by index cursors */
115 u32 iHdrOffset
; /* Offset to next unparsed byte of the header */
116 Pgno pgnoRoot
; /* Root page of the open btree cursor */
117 i16 nField
; /* Number of fields in the header */
118 u16 nHdrParsed
; /* Number of header fields parsed so far */
119 i64 movetoTarget
; /* Argument to the deferred sqlite3BtreeMoveto() */
120 u32
*aOffset
; /* Pointer to aType[nField] */
121 const u8
*aRow
; /* Data for the current row, if all on one page */
122 u32 payloadSize
; /* Total number of bytes in the record */
123 u32 szRow
; /* Byte available in aRow */
124 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
125 u64 maskUsed
; /* Mask of columns used by this cursor */
128 /* 2*nField extra array elements allocated for aType[], beyond the one
129 ** static element declared in the structure. nField total array slots for
130 ** aType[] and nField+1 array slots for aOffset[] */
131 u32 aType
[1]; /* Type values record decode. MUST BE LAST */
136 ** A value for VdbeCursor.cacheStatus that means the cache is always invalid.
138 #define CACHE_STALE 0
141 ** When a sub-program is executed (OP_Program), a structure of this type
142 ** is allocated to store the current value of the program counter, as
143 ** well as the current memory cell array and various other frame specific
144 ** values stored in the Vdbe struct. When the sub-program is finished,
145 ** these values are copied back to the Vdbe from the VdbeFrame structure,
146 ** restoring the state of the VM to as it was before the sub-program
149 ** The memory for a VdbeFrame object is allocated and managed by a memory
150 ** cell in the parent (calling) frame. When the memory cell is deleted or
151 ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
152 ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
153 ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
154 ** this instead of deleting the VdbeFrame immediately is to avoid recursive
155 ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
156 ** child frame are released.
158 ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
159 ** set to NULL if the currently executing frame is the main program.
161 typedef struct VdbeFrame VdbeFrame
;
163 Vdbe
*v
; /* VM this frame belongs to */
164 VdbeFrame
*pParent
; /* Parent of this frame, or NULL if parent is main */
165 Op
*aOp
; /* Program instructions for parent frame */
166 i64
*anExec
; /* Event counters from parent frame */
167 Mem
*aMem
; /* Array of memory cells for parent frame */
168 VdbeCursor
**apCsr
; /* Array of Vdbe cursors for parent frame */
169 u8
*aOnce
; /* Bitmask used by OP_Once */
170 void *token
; /* Copy of SubProgram.token */
171 i64 lastRowid
; /* Last insert rowid (sqlite3.lastRowid) */
172 AuxData
*pAuxData
; /* Linked list of auxdata allocations */
174 u32 iFrameMagic
; /* magic number for sanity checking */
176 int nCursor
; /* Number of entries in apCsr */
177 int pc
; /* Program Counter in parent (calling) frame */
178 int nOp
; /* Size of aOp array */
179 int nMem
; /* Number of entries in aMem */
180 int nChildMem
; /* Number of memory cells for child frame */
181 int nChildCsr
; /* Number of cursors for child frame */
182 int nChange
; /* Statement changes (Vdbe.nChange) */
183 int nDbChange
; /* Value of db->nChange */
186 /* Magic number for sanity checking on VdbeFrame objects */
187 #define SQLITE_FRAME_MAGIC 0x879fb71e
190 ** Return a pointer to the array of registers allocated for use
193 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
196 ** Internally, the vdbe manipulates nearly all SQL values as Mem
197 ** structures. Each Mem struct may cache multiple representations (string,
198 ** integer etc.) of the same value.
200 struct sqlite3_value
{
202 double r
; /* Real value used when MEM_Real is set in flags */
203 i64 i
; /* Integer value used when MEM_Int is set in flags */
204 int nZero
; /* Extra zero bytes when MEM_Zero and MEM_Blob set */
205 const char *zPType
; /* Pointer type when MEM_Term|MEM_Subtype|MEM_Null */
206 FuncDef
*pDef
; /* Used only when flags==MEM_Agg */
208 u16 flags
; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
209 u8 enc
; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
210 u8 eSubtype
; /* Subtype for this value */
211 int n
; /* Number of characters in string value, excluding '\0' */
212 char *z
; /* String or BLOB value */
213 /* ShallowCopy only needs to copy the information above */
214 char *zMalloc
; /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */
215 int szMalloc
; /* Size of the zMalloc allocation */
216 u32 uTemp
; /* Transient storage for serial_type in OP_MakeRecord */
217 sqlite3
*db
; /* The associated database connection */
218 void (*xDel
)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
220 Mem
*pScopyFrom
; /* This Mem is a shallow copy of pScopyFrom */
221 u16 mScopyFlags
; /* flags value immediately after the shallow copy */
226 ** Size of struct Mem not including the Mem.zMalloc member or anything that
229 #define MEMCELLSIZE offsetof(Mem,zMalloc)
231 /* One or more of the following flags are set to indicate the validOK
232 ** representations of the value stored in the Mem struct.
234 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
235 ** For a pointer type created using sqlite3_bind_pointer() or
236 ** sqlite3_result_pointer() the MEM_Term and MEM_Subtype flags are also set.
238 ** If the MEM_Str flag is set then Mem.z points at a string representation.
239 ** Usually this is encoded in the same unicode encoding as the main
240 ** database (see below for exceptions). If the MEM_Term flag is also
241 ** set, then the string is nul terminated. The MEM_Int and MEM_Real
242 ** flags may coexist with the MEM_Str flag.
244 #define MEM_Null 0x0001 /* Value is NULL (or a pointer) */
245 #define MEM_Str 0x0002 /* Value is a string */
246 #define MEM_Int 0x0004 /* Value is an integer */
247 #define MEM_Real 0x0008 /* Value is a real number */
248 #define MEM_Blob 0x0010 /* Value is a BLOB */
249 #define MEM_IntReal 0x0020 /* MEM_Int that stringifies like MEM_Real */
250 #define MEM_AffMask 0x003f /* Mask of affinity bits */
251 #define MEM_FromBind 0x0040 /* Value originates from sqlite3_bind() */
252 #define MEM_Undefined 0x0080 /* Value is undefined */
253 #define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */
254 #define MEM_TypeMask 0xc1bf /* Mask of type bits */
257 /* Whenever Mem contains a valid string or blob representation, one of
258 ** the following flags must be set to determine the memory management
259 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
260 ** string is \000 or \u0000 terminated
262 #define MEM_Term 0x0200 /* String in Mem.z is zero terminated */
263 #define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */
264 #define MEM_Static 0x0800 /* Mem.z points to a static string */
265 #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
266 #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
267 #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
268 #define MEM_Subtype 0x8000 /* Mem.eSubtype is valid */
269 #ifdef SQLITE_OMIT_INCRBLOB
271 #define MEM_Zero 0x0000
274 /* Return TRUE if Mem X contains dynamically allocated content - anything
275 ** that needs to be deallocated to avoid a leak.
277 #define VdbeMemDynamic(X) \
278 (((X)->flags&(MEM_Agg|MEM_Dyn))!=0)
281 ** Clear any existing type flags from a Mem and replace them with f
283 #define MemSetTypeFlag(p, f) \
284 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
287 ** True if Mem X is a NULL-nochng type.
289 #define MemNullNochng(X) \
290 (((X)->flags&MEM_TypeMask)==(MEM_Null|MEM_Zero) \
291 && (X)->n==0 && (X)->u.nZero==0)
294 ** Return true if a memory cell is not marked as invalid. This macro
295 ** is for use inside assert() statements only.
298 #define memIsValid(M) ((M)->flags & MEM_Undefined)==0
302 ** Each auxiliary data pointer stored by a user defined function
303 ** implementation calling sqlite3_set_auxdata() is stored in an instance
304 ** of this structure. All such structures associated with a single VM
305 ** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed
306 ** when the VM is halted (if not before).
309 int iAuxOp
; /* Instruction number of OP_Function opcode */
310 int iAuxArg
; /* Index of function argument. */
311 void *pAux
; /* Aux data pointer */
312 void (*xDeleteAux
)(void*); /* Destructor for the aux data */
313 AuxData
*pNextAux
; /* Next element in list */
317 ** The "context" argument for an installable function. A pointer to an
318 ** instance of this structure is the first argument to the routines used
319 ** implement the SQL functions.
321 ** There is a typedef for this structure in sqlite.h. So all routines,
322 ** even the public interface to SQLite, can use a pointer to this structure.
323 ** But this file is the only place where the internal details of this
324 ** structure are known.
326 ** This structure is defined inside of vdbeInt.h because it uses substructures
327 ** (Mem) which are only defined there.
329 struct sqlite3_context
{
330 Mem
*pOut
; /* The return value is stored here */
331 FuncDef
*pFunc
; /* Pointer to function information */
332 Mem
*pMem
; /* Memory cell used to store aggregate context */
333 Vdbe
*pVdbe
; /* The VM that owns this context */
334 int iOp
; /* Instruction number of OP_Function */
335 int isError
; /* Error code returned by the function. */
336 u8 skipFlag
; /* Skip accumulator loading if true */
337 u8 argc
; /* Number of arguments */
338 sqlite3_value
*argv
[1]; /* Argument set */
341 /* A bitfield type for use inside of structures. Always follow with :N where
342 ** N is the number of bits.
344 typedef unsigned bft
; /* Bit Field Type */
346 /* The ScanStatus object holds a single value for the
347 ** sqlite3_stmt_scanstatus() interface.
349 typedef struct ScanStatus ScanStatus
;
351 int addrExplain
; /* OP_Explain for loop */
352 int addrLoop
; /* Address of "loops" counter */
353 int addrVisit
; /* Address of "rows visited" counter */
354 int iSelectID
; /* The "Select-ID" for this loop */
355 LogEst nEst
; /* Estimated output rows per loop */
356 char *zName
; /* Name of table or index */
359 /* The DblquoteStr object holds the text of a double-quoted
360 ** string for a prepared statement. A linked list of these objects
361 ** is constructed during statement parsing and is held on Vdbe.pDblStr.
362 ** When computing a normalized SQL statement for an SQL statement, that
363 ** list is consulted for each double-quoted identifier to see if the
364 ** identifier should really be a string literal.
366 typedef struct DblquoteStr DblquoteStr
;
368 DblquoteStr
*pNextStr
; /* Next string literal in the list */
369 char z
[8]; /* Dequoted value for the string */
373 ** An instance of the virtual machine. This structure contains the complete
374 ** state of the virtual machine.
376 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
377 ** is really a pointer to an instance of this structure.
380 sqlite3
*db
; /* The database connection that owns this statement */
381 Vdbe
*pPrev
,*pNext
; /* Linked list of VDBEs with the same Vdbe.db */
382 Parse
*pParse
; /* Parsing context used to create this Vdbe */
383 ynVar nVar
; /* Number of entries in aVar[] */
384 u32 magic
; /* Magic number for sanity checking */
385 int nMem
; /* Number of memory locations currently allocated */
386 int nCursor
; /* Number of slots in apCsr[] */
387 u32 cacheCtr
; /* VdbeCursor row cache generation counter */
388 int pc
; /* The program counter */
389 int rc
; /* Value to return */
390 int nChange
; /* Number of db changes made since last reset */
391 int iStatement
; /* Statement number (or 0 if has no opened stmt) */
392 i64 iCurrentTime
; /* Value of julianday('now') for this statement */
393 i64 nFkConstraint
; /* Number of imm. FK constraints this VM */
394 i64 nStmtDefCons
; /* Number of def. constraints when stmt started */
395 i64 nStmtDefImmCons
; /* Number of def. imm constraints when stmt started */
396 Mem
*aMem
; /* The memory locations */
397 Mem
**apArg
; /* Arguments to currently executing user function */
398 VdbeCursor
**apCsr
; /* One element of this array for each open cursor */
399 Mem
*aVar
; /* Values for the OP_Variable opcode. */
401 /* When allocating a new Vdbe object, all of the fields below should be
402 ** initialized to zero or NULL */
404 Op
*aOp
; /* Space to hold the virtual machine's program */
405 int nOp
; /* Number of instructions in the program */
406 int nOpAlloc
; /* Slots allocated for aOp[] */
407 Mem
*aColName
; /* Column names to return */
408 Mem
*pResultSet
; /* Pointer to an array of results */
409 char *zErrMsg
; /* Error message written here */
410 VList
*pVList
; /* Name of variables */
411 #ifndef SQLITE_OMIT_TRACE
412 i64 startTime
; /* Time when query started - used for profiling */
415 int rcApp
; /* errcode set by sqlite3_result_error_code() */
416 u32 nWrite
; /* Number of write operations that have occurred */
418 u16 nResColumn
; /* Number of columns in one row of the result set */
419 u8 errorAction
; /* Recovery action to do in case of an error */
420 u8 minWriteFileFormat
; /* Minimum file format for writable database files */
421 u8 prepFlags
; /* SQLITE_PREPARE_* flags */
422 u8 doingRerun
; /* True if rerunning after an auto-reprepare */
423 bft expired
:2; /* 1: recompile VM immediately 2: when convenient */
424 bft explain
:2; /* True if EXPLAIN present on SQL command */
425 bft changeCntOn
:1; /* True to update the change-counter */
426 bft runOnlyOnce
:1; /* Automatically expire on reset */
427 bft usesStmtJournal
:1; /* True if uses a statement journal */
428 bft readOnly
:1; /* True for statements that do not write */
429 bft bIsReader
:1; /* True for statements that read */
430 yDbMask btreeMask
; /* Bitmask of db->aDb[] entries referenced */
431 yDbMask lockMask
; /* Subset of btreeMask that requires a lock */
432 u32 aCounter
[7]; /* Counters used by sqlite3_stmt_status() */
433 char *zSql
; /* Text of the SQL statement that generated this */
434 #ifdef SQLITE_ENABLE_NORMALIZE
435 char *zNormSql
; /* Normalization of the associated SQL statement */
436 DblquoteStr
*pDblStr
; /* List of double-quoted string literals */
438 void *pFree
; /* Free this when deleting the vdbe */
439 VdbeFrame
*pFrame
; /* Parent frame */
440 VdbeFrame
*pDelFrame
; /* List of frame objects to free on VM reset */
441 int nFrame
; /* Number of frames in pFrame list */
442 u32 expmask
; /* Binding to these vars invalidates VM */
443 SubProgram
*pProgram
; /* Linked list of all sub-programs used by VM */
444 AuxData
*pAuxData
; /* Linked list of auxdata allocations */
445 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
446 i64
*anExec
; /* Number of times each op has been executed */
447 int nScan
; /* Entries in aScan[] */
448 ScanStatus
*aScan
; /* Scan definitions for sqlite3_stmt_scanstatus() */
453 ** The following are allowed values for Vdbe.magic
455 #define VDBE_MAGIC_INIT 0x16bceaa5 /* Building a VDBE program */
456 #define VDBE_MAGIC_RUN 0x2df20da3 /* VDBE is ready to execute */
457 #define VDBE_MAGIC_HALT 0x319c2973 /* VDBE has completed execution */
458 #define VDBE_MAGIC_RESET 0x48fa9f76 /* Reset and ready to run again */
459 #define VDBE_MAGIC_DEAD 0x5606c3c8 /* The VDBE has been deallocated */
462 ** Structure used to store the context required by the
463 ** sqlite3_preupdate_*() API functions.
467 VdbeCursor
*pCsr
; /* Cursor to read old values from */
468 int op
; /* One of SQLITE_INSERT, UPDATE, DELETE */
469 u8
*aRecord
; /* old.* database record */
471 UnpackedRecord
*pUnpacked
; /* Unpacked version of aRecord[] */
472 UnpackedRecord
*pNewUnpacked
; /* Unpacked version of new.* record */
473 int iNewReg
; /* Register for new.* values */
474 i64 iKey1
; /* First key value passed to hook */
475 i64 iKey2
; /* Second key value passed to hook */
476 Mem
*aNew
; /* Array of new.* values */
477 Table
*pTab
; /* Schema object being upated */
478 Index
*pPk
; /* PK index if pTab is WITHOUT ROWID */
482 ** Function prototypes
484 void sqlite3VdbeError(Vdbe
*, const char *, ...);
485 void sqlite3VdbeFreeCursor(Vdbe
*, VdbeCursor
*);
486 void sqliteVdbePopStack(Vdbe
*,int);
487 int SQLITE_NOINLINE
sqlite3VdbeFinishMoveto(VdbeCursor
*);
488 int sqlite3VdbeCursorMoveto(VdbeCursor
**, u32
*);
489 int sqlite3VdbeCursorRestore(VdbeCursor
*);
490 u32
sqlite3VdbeSerialTypeLen(u32
);
491 u8
sqlite3VdbeOneByteSerialTypeLen(u8
);
492 u32
sqlite3VdbeSerialPut(unsigned char*, Mem
*, u32
);
493 u32
sqlite3VdbeSerialGet(const unsigned char*, u32
, Mem
*);
494 void sqlite3VdbeDeleteAuxData(sqlite3
*, AuxData
**, int, int);
496 int sqlite2BtreeKeyCompare(BtCursor
*, const void *, int, int, int *);
497 int sqlite3VdbeIdxKeyCompare(sqlite3
*,VdbeCursor
*,UnpackedRecord
*,int*);
498 int sqlite3VdbeIdxRowid(sqlite3
*, BtCursor
*, i64
*);
499 int sqlite3VdbeExec(Vdbe
*);
500 #if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB)
501 int sqlite3VdbeNextOpcode(Vdbe
*,Mem
*,int,int*,int*,Op
**);
502 char *sqlite3VdbeDisplayP4(sqlite3
*,Op
*);
504 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS)
505 char *sqlite3VdbeDisplayComment(sqlite3
*,const Op
*,const char*);
507 #if !defined(SQLITE_OMIT_EXPLAIN)
508 int sqlite3VdbeList(Vdbe
*);
510 int sqlite3VdbeHalt(Vdbe
*);
511 int sqlite3VdbeChangeEncoding(Mem
*, int);
512 int sqlite3VdbeMemTooBig(Mem
*);
513 int sqlite3VdbeMemCopy(Mem
*, const Mem
*);
514 void sqlite3VdbeMemShallowCopy(Mem
*, const Mem
*, int);
515 void sqlite3VdbeMemMove(Mem
*, Mem
*);
516 int sqlite3VdbeMemNulTerminate(Mem
*);
517 int sqlite3VdbeMemSetStr(Mem
*, const char*, int, u8
, void(*)(void*));
518 void sqlite3VdbeMemSetInt64(Mem
*, i64
);
519 #ifdef SQLITE_OMIT_FLOATING_POINT
520 # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
522 void sqlite3VdbeMemSetDouble(Mem
*, double);
524 void sqlite3VdbeMemSetPointer(Mem
*, void*, const char*, void(*)(void*));
525 void sqlite3VdbeMemInit(Mem
*,sqlite3
*,u16
);
526 void sqlite3VdbeMemSetNull(Mem
*);
527 void sqlite3VdbeMemSetZeroBlob(Mem
*,int);
529 int sqlite3VdbeMemIsRowSet(const Mem
*);
531 int sqlite3VdbeMemSetRowSet(Mem
*);
532 int sqlite3VdbeMemMakeWriteable(Mem
*);
533 int sqlite3VdbeMemStringify(Mem
*, u8
, u8
);
534 i64
sqlite3VdbeIntValue(Mem
*);
535 int sqlite3VdbeMemIntegerify(Mem
*);
536 double sqlite3VdbeRealValue(Mem
*);
537 int sqlite3VdbeBooleanValue(Mem
*, int ifNull
);
538 void sqlite3VdbeIntegerAffinity(Mem
*);
539 int sqlite3VdbeMemRealify(Mem
*);
540 int sqlite3VdbeMemNumerify(Mem
*);
541 int sqlite3VdbeMemCast(Mem
*,u8
,u8
);
542 int sqlite3VdbeMemFromBtree(BtCursor
*,u32
,u32
,Mem
*);
543 int sqlite3VdbeMemFromBtreeZeroOffset(BtCursor
*,u32
,Mem
*);
544 void sqlite3VdbeMemRelease(Mem
*p
);
545 int sqlite3VdbeMemFinalize(Mem
*, FuncDef
*);
546 #ifndef SQLITE_OMIT_WINDOWFUNC
547 int sqlite3VdbeMemAggValue(Mem
*, Mem
*, FuncDef
*);
549 #if !defined(SQLITE_OMIT_EXPLAIN) || defined(SQLITE_ENABLE_BYTECODE_VTAB)
550 const char *sqlite3OpcodeName(int);
552 int sqlite3VdbeMemGrow(Mem
*pMem
, int n
, int preserve
);
553 int sqlite3VdbeMemClearAndResize(Mem
*pMem
, int n
);
554 int sqlite3VdbeCloseStatement(Vdbe
*, int);
556 int sqlite3VdbeFrameIsValid(VdbeFrame
*);
558 void sqlite3VdbeFrameMemDel(void*); /* Destructor on Mem */
559 void sqlite3VdbeFrameDelete(VdbeFrame
*); /* Actually deletes the Frame */
560 int sqlite3VdbeFrameRestore(VdbeFrame
*);
561 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
562 void sqlite3VdbePreUpdateHook(Vdbe
*,VdbeCursor
*,int,const char*,Table
*,i64
,int);
564 int sqlite3VdbeTransferError(Vdbe
*p
);
566 int sqlite3VdbeSorterInit(sqlite3
*, int, VdbeCursor
*);
567 void sqlite3VdbeSorterReset(sqlite3
*, VdbeSorter
*);
568 void sqlite3VdbeSorterClose(sqlite3
*, VdbeCursor
*);
569 int sqlite3VdbeSorterRowkey(const VdbeCursor
*, Mem
*);
570 int sqlite3VdbeSorterNext(sqlite3
*, const VdbeCursor
*);
571 int sqlite3VdbeSorterRewind(const VdbeCursor
*, int *);
572 int sqlite3VdbeSorterWrite(const VdbeCursor
*, Mem
*);
573 int sqlite3VdbeSorterCompare(const VdbeCursor
*, Mem
*, int, int *);
576 void sqlite3VdbeIncrWriteCounter(Vdbe
*, VdbeCursor
*);
577 void sqlite3VdbeAssertAbortable(Vdbe
*);
579 # define sqlite3VdbeIncrWriteCounter(V,C)
580 # define sqlite3VdbeAssertAbortable(V)
583 #if !defined(SQLITE_OMIT_SHARED_CACHE)
584 void sqlite3VdbeEnter(Vdbe
*);
586 # define sqlite3VdbeEnter(X)
589 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
590 void sqlite3VdbeLeave(Vdbe
*);
592 # define sqlite3VdbeLeave(X)
596 void sqlite3VdbeMemAboutToChange(Vdbe
*,Mem
*);
597 int sqlite3VdbeCheckMemInvariants(Mem
*);
600 #ifndef SQLITE_OMIT_FOREIGN_KEY
601 int sqlite3VdbeCheckFk(Vdbe
*, int);
603 # define sqlite3VdbeCheckFk(p,i) 0
607 void sqlite3VdbePrintSql(Vdbe
*);
608 void sqlite3VdbeMemPrettyPrint(Mem
*pMem
, StrAccum
*pStr
);
610 #ifndef SQLITE_OMIT_UTF16
611 int sqlite3VdbeMemTranslate(Mem
*, u8
);
612 int sqlite3VdbeMemHandleBom(Mem
*pMem
);
615 #ifndef SQLITE_OMIT_INCRBLOB
616 int sqlite3VdbeMemExpandBlob(Mem
*);
617 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
619 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
620 #define ExpandBlob(P) SQLITE_OK
623 #endif /* !defined(SQLITE_VDBEINT_H) */