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 # define VDBE_DISPLAY_P4 1
37 # define VDBE_DISPLAY_P4 0
41 ** SQL is translated into a sequence of instructions to be
42 ** executed by a virtual machine. Each instruction is an instance
43 ** of the following structure.
45 typedef struct VdbeOp Op
;
50 typedef unsigned Bool
;
52 /* Opaque type used by code in vdbesort.c */
53 typedef struct VdbeSorter VdbeSorter
;
55 /* Elements of the linked list at Vdbe.pAuxData */
56 typedef struct AuxData AuxData
;
58 /* Types of VDBE cursors */
59 #define CURTYPE_BTREE 0
60 #define CURTYPE_SORTER 1
61 #define CURTYPE_VTAB 2
62 #define CURTYPE_PSEUDO 3
65 ** A VdbeCursor is an superclass (a wrapper) for various cursor objects:
68 ** - In the main database or in an ephemeral database
69 ** - On either an index or a table
72 ** * A one-row "pseudotable" stored in a single register
74 typedef struct VdbeCursor VdbeCursor
;
76 u8 eCurType
; /* One of the CURTYPE_* values above */
77 i8 iDb
; /* Index of cursor database in db->aDb[] (or -1) */
78 u8 nullRow
; /* True if pointing to a row with no data */
79 u8 deferredMoveto
; /* A call to sqlite3BtreeMoveto() is needed */
80 u8 isTable
; /* True for rowid tables. False for indexes */
82 u8 seekOp
; /* Most recent seek operation on this cursor */
83 u8 wrFlag
; /* The wrFlag argument to sqlite3BtreeCursor() */
85 Bool isEphemeral
:1; /* True for an ephemeral table */
86 Bool useRandomRowid
:1; /* Generate new record numbers semi-randomly */
87 Bool isOrdered
:1; /* True if the table is not BTREE_UNORDERED */
88 Bool seekHit
:1; /* See the OP_SeekHit and OP_IfNoHope opcodes */
89 Btree
*pBtx
; /* Separate file holding temporary table */
90 i64 seqCount
; /* Sequence counter */
91 int *aAltMap
; /* Mapping from table to index column numbers */
93 /* Cached OP_Column parse information is only valid if cacheStatus matches
94 ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
95 ** CACHE_STALE (0) and so setting cacheStatus=CACHE_STALE guarantees that
96 ** the cache is out of date. */
97 u32 cacheStatus
; /* Cache is valid if this matches Vdbe.cacheCtr */
98 int seekResult
; /* Result of previous sqlite3BtreeMoveto() or 0
99 ** if there have been no prior seeks on the cursor. */
100 /* seekResult does not distinguish between "no seeks have ever occurred
101 ** on this cursor" and "the most recent seek was an exact match".
102 ** For CURTYPE_PSEUDO, seekResult is the register holding the record */
104 /* When a new VdbeCursor is allocated, only the fields above are zeroed.
105 ** The fields that follow are uninitialized, and must be individually
106 ** initialized prior to first use. */
107 VdbeCursor
*pAltCursor
; /* Associated index cursor from which to read */
109 BtCursor
*pCursor
; /* CURTYPE_BTREE or _PSEUDO. Btree cursor */
110 sqlite3_vtab_cursor
*pVCur
; /* CURTYPE_VTAB. Vtab cursor */
111 VdbeSorter
*pSorter
; /* CURTYPE_SORTER. Sorter object */
113 KeyInfo
*pKeyInfo
; /* Info about index keys needed by index cursors */
114 u32 iHdrOffset
; /* Offset to next unparsed byte of the header */
115 Pgno pgnoRoot
; /* Root page of the open btree cursor */
116 i16 nField
; /* Number of fields in the header */
117 u16 nHdrParsed
; /* Number of header fields parsed so far */
118 i64 movetoTarget
; /* Argument to the deferred sqlite3BtreeMoveto() */
119 u32
*aOffset
; /* Pointer to aType[nField] */
120 const u8
*aRow
; /* Data for the current row, if all on one page */
121 u32 payloadSize
; /* Total number of bytes in the record */
122 u32 szRow
; /* Byte available in aRow */
123 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
124 u64 maskUsed
; /* Mask of columns used by this cursor */
127 /* 2*nField extra array elements allocated for aType[], beyond the one
128 ** static element declared in the structure. nField total array slots for
129 ** aType[] and nField+1 array slots for aOffset[] */
130 u32 aType
[1]; /* Type values record decode. MUST BE LAST */
135 ** A value for VdbeCursor.cacheStatus that means the cache is always invalid.
137 #define CACHE_STALE 0
140 ** When a sub-program is executed (OP_Program), a structure of this type
141 ** is allocated to store the current value of the program counter, as
142 ** well as the current memory cell array and various other frame specific
143 ** values stored in the Vdbe struct. When the sub-program is finished,
144 ** these values are copied back to the Vdbe from the VdbeFrame structure,
145 ** restoring the state of the VM to as it was before the sub-program
148 ** The memory for a VdbeFrame object is allocated and managed by a memory
149 ** cell in the parent (calling) frame. When the memory cell is deleted or
150 ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
151 ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
152 ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
153 ** this instead of deleting the VdbeFrame immediately is to avoid recursive
154 ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
155 ** child frame are released.
157 ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
158 ** set to NULL if the currently executing frame is the main program.
160 typedef struct VdbeFrame VdbeFrame
;
162 Vdbe
*v
; /* VM this frame belongs to */
163 VdbeFrame
*pParent
; /* Parent of this frame, or NULL if parent is main */
164 Op
*aOp
; /* Program instructions for parent frame */
165 i64
*anExec
; /* Event counters from parent frame */
166 Mem
*aMem
; /* Array of memory cells for parent frame */
167 VdbeCursor
**apCsr
; /* Array of Vdbe cursors for parent frame */
168 u8
*aOnce
; /* Bitmask used by OP_Once */
169 void *token
; /* Copy of SubProgram.token */
170 i64 lastRowid
; /* Last insert rowid (sqlite3.lastRowid) */
171 AuxData
*pAuxData
; /* Linked list of auxdata allocations */
172 int nCursor
; /* Number of entries in apCsr */
173 int pc
; /* Program Counter in parent (calling) frame */
174 int nOp
; /* Size of aOp array */
175 int nMem
; /* Number of entries in aMem */
176 int nChildMem
; /* Number of memory cells for child frame */
177 int nChildCsr
; /* Number of cursors for child frame */
178 int nChange
; /* Statement changes (Vdbe.nChange) */
179 int nDbChange
; /* Value of db->nChange */
182 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
185 ** Internally, the vdbe manipulates nearly all SQL values as Mem
186 ** structures. Each Mem struct may cache multiple representations (string,
187 ** integer etc.) of the same value.
189 struct sqlite3_value
{
191 double r
; /* Real value used when MEM_Real is set in flags */
192 i64 i
; /* Integer value used when MEM_Int is set in flags */
193 int nZero
; /* Extra zero bytes when MEM_Zero and MEM_Blob set */
194 const char *zPType
; /* Pointer type when MEM_Term|MEM_Subtype|MEM_Null */
195 FuncDef
*pDef
; /* Used only when flags==MEM_Agg */
196 RowSet
*pRowSet
; /* Used only when flags==MEM_RowSet */
197 VdbeFrame
*pFrame
; /* Used when flags==MEM_Frame */
199 u16 flags
; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
200 u8 enc
; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
201 u8 eSubtype
; /* Subtype for this value */
202 int n
; /* Number of characters in string value, excluding '\0' */
203 char *z
; /* String or BLOB value */
204 /* ShallowCopy only needs to copy the information above */
205 char *zMalloc
; /* Space to hold MEM_Str or MEM_Blob if szMalloc>0 */
206 int szMalloc
; /* Size of the zMalloc allocation */
207 u32 uTemp
; /* Transient storage for serial_type in OP_MakeRecord */
208 sqlite3
*db
; /* The associated database connection */
209 void (*xDel
)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
211 Mem
*pScopyFrom
; /* This Mem is a shallow copy of pScopyFrom */
212 u16 mScopyFlags
; /* flags value immediately after the shallow copy */
214 #ifdef SQLITE_DEBUG_COLUMNCACHE
215 u32 iTabColHash
; /* Hash of table.column that is origin of this value */
216 u32 iPadding
; /* sqlite3_value objects must be 8-byte aligned */
221 ** Size of struct Mem not including the Mem.zMalloc member or anything that
224 #define MEMCELLSIZE offsetof(Mem,zMalloc)
226 /* One or more of the following flags are set to indicate the validOK
227 ** representations of the value stored in the Mem struct.
229 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
230 ** For a pointer type created using sqlite3_bind_pointer() or
231 ** sqlite3_result_pointer() the MEM_Term and MEM_Subtype flags are also set.
233 ** If the MEM_Str flag is set then Mem.z points at a string representation.
234 ** Usually this is encoded in the same unicode encoding as the main
235 ** database (see below for exceptions). If the MEM_Term flag is also
236 ** set, then the string is nul terminated. The MEM_Int and MEM_Real
237 ** flags may coexist with the MEM_Str flag.
239 #define MEM_Null 0x0001 /* Value is NULL (or a pointer) */
240 #define MEM_Str 0x0002 /* Value is a string */
241 #define MEM_Int 0x0004 /* Value is an integer */
242 #define MEM_Real 0x0008 /* Value is a real number */
243 #define MEM_Blob 0x0010 /* Value is a BLOB */
244 #define MEM_AffMask 0x001f /* Mask of affinity bits */
245 #define MEM_RowSet 0x0020 /* Value is a RowSet object */
246 #define MEM_Frame 0x0040 /* Value is a VdbeFrame object */
247 #define MEM_Undefined 0x0080 /* Value is undefined */
248 #define MEM_Cleared 0x0100 /* NULL set by OP_Null, not from data */
249 #define MEM_TypeMask 0xc1ff /* Mask of type bits */
252 /* Whenever Mem contains a valid string or blob representation, one of
253 ** the following flags must be set to determine the memory management
254 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
255 ** string is \000 or \u0000 terminated
257 #define MEM_Term 0x0200 /* String in Mem.z is zero terminated */
258 #define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */
259 #define MEM_Static 0x0800 /* Mem.z points to a static string */
260 #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
261 #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
262 #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
263 #define MEM_Subtype 0x8000 /* Mem.eSubtype is valid */
264 #ifdef SQLITE_OMIT_INCRBLOB
266 #define MEM_Zero 0x0000
269 /* Return TRUE if Mem X contains dynamically allocated content - anything
270 ** that needs to be deallocated to avoid a leak.
272 #define VdbeMemDynamic(X) \
273 (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)
276 ** Clear any existing type flags from a Mem and replace them with f
278 #define MemSetTypeFlag(p, f) \
279 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
282 ** Return true if a memory cell is not marked as invalid. This macro
283 ** is for use inside assert() statements only.
286 #define memIsValid(M) ((M)->flags & MEM_Undefined)==0
290 ** Each auxiliary data pointer stored by a user defined function
291 ** implementation calling sqlite3_set_auxdata() is stored in an instance
292 ** of this structure. All such structures associated with a single VM
293 ** are stored in a linked list headed at Vdbe.pAuxData. All are destroyed
294 ** when the VM is halted (if not before).
297 int iAuxOp
; /* Instruction number of OP_Function opcode */
298 int iAuxArg
; /* Index of function argument. */
299 void *pAux
; /* Aux data pointer */
300 void (*xDeleteAux
)(void*); /* Destructor for the aux data */
301 AuxData
*pNextAux
; /* Next element in list */
305 ** The "context" argument for an installable function. A pointer to an
306 ** instance of this structure is the first argument to the routines used
307 ** implement the SQL functions.
309 ** There is a typedef for this structure in sqlite.h. So all routines,
310 ** even the public interface to SQLite, can use a pointer to this structure.
311 ** But this file is the only place where the internal details of this
312 ** structure are known.
314 ** This structure is defined inside of vdbeInt.h because it uses substructures
315 ** (Mem) which are only defined there.
317 struct sqlite3_context
{
318 Mem
*pOut
; /* The return value is stored here */
319 FuncDef
*pFunc
; /* Pointer to function information */
320 Mem
*pMem
; /* Memory cell used to store aggregate context */
321 Vdbe
*pVdbe
; /* The VM that owns this context */
322 int iOp
; /* Instruction number of OP_Function */
323 int isError
; /* Error code returned by the function. */
324 u8 skipFlag
; /* Skip accumulator loading if true */
325 u8 argc
; /* Number of arguments */
326 sqlite3_value
*argv
[1]; /* Argument set */
329 /* A bitfield type for use inside of structures. Always follow with :N where
330 ** N is the number of bits.
332 typedef unsigned bft
; /* Bit Field Type */
334 typedef struct ScanStatus ScanStatus
;
336 int addrExplain
; /* OP_Explain for loop */
337 int addrLoop
; /* Address of "loops" counter */
338 int addrVisit
; /* Address of "rows visited" counter */
339 int iSelectID
; /* The "Select-ID" for this loop */
340 LogEst nEst
; /* Estimated output rows per loop */
341 char *zName
; /* Name of table or index */
345 ** An instance of the virtual machine. This structure contains the complete
346 ** state of the virtual machine.
348 ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
349 ** is really a pointer to an instance of this structure.
352 sqlite3
*db
; /* The database connection that owns this statement */
353 Vdbe
*pPrev
,*pNext
; /* Linked list of VDBEs with the same Vdbe.db */
354 Parse
*pParse
; /* Parsing context used to create this Vdbe */
355 ynVar nVar
; /* Number of entries in aVar[] */
356 u32 magic
; /* Magic number for sanity checking */
357 int nMem
; /* Number of memory locations currently allocated */
358 int nCursor
; /* Number of slots in apCsr[] */
359 u32 cacheCtr
; /* VdbeCursor row cache generation counter */
360 int pc
; /* The program counter */
361 int rc
; /* Value to return */
362 int nChange
; /* Number of db changes made since last reset */
363 int iStatement
; /* Statement number (or 0 if has not opened stmt) */
364 i64 iCurrentTime
; /* Value of julianday('now') for this statement */
365 i64 nFkConstraint
; /* Number of imm. FK constraints this VM */
366 i64 nStmtDefCons
; /* Number of def. constraints when stmt started */
367 i64 nStmtDefImmCons
; /* Number of def. imm constraints when stmt started */
369 /* When allocating a new Vdbe object, all of the fields below should be
370 ** initialized to zero or NULL */
372 Op
*aOp
; /* Space to hold the virtual machine's program */
373 Mem
*aMem
; /* The memory locations */
374 Mem
**apArg
; /* Arguments to currently executing user function */
375 Mem
*aColName
; /* Column names to return */
376 Mem
*pResultSet
; /* Pointer to an array of results */
377 char *zErrMsg
; /* Error message written here */
378 VdbeCursor
**apCsr
; /* One element of this array for each open cursor */
379 Mem
*aVar
; /* Values for the OP_Variable opcode. */
380 VList
*pVList
; /* Name of variables */
381 #ifndef SQLITE_OMIT_TRACE
382 i64 startTime
; /* Time when query started - used for profiling */
384 int nOp
; /* Number of instructions in the program */
386 int rcApp
; /* errcode set by sqlite3_result_error_code() */
387 u32 nWrite
; /* Number of write operations that have occurred */
389 u16 nResColumn
; /* Number of columns in one row of the result set */
390 u8 errorAction
; /* Recovery action to do in case of an error */
391 u8 minWriteFileFormat
; /* Minimum file format for writable database files */
392 u8 prepFlags
; /* SQLITE_PREPARE_* flags */
393 bft expired
:1; /* True if the VM needs to be recompiled */
394 bft doingRerun
:1; /* True if rerunning after an auto-reprepare */
395 bft explain
:2; /* True if EXPLAIN present on SQL command */
396 bft changeCntOn
:1; /* True to update the change-counter */
397 bft runOnlyOnce
:1; /* Automatically expire on reset */
398 bft usesStmtJournal
:1; /* True if uses a statement journal */
399 bft readOnly
:1; /* True for statements that do not write */
400 bft bIsReader
:1; /* True for statements that read */
401 yDbMask btreeMask
; /* Bitmask of db->aDb[] entries referenced */
402 yDbMask lockMask
; /* Subset of btreeMask that requires a lock */
403 u32 aCounter
[7]; /* Counters used by sqlite3_stmt_status() */
404 char *zSql
; /* Text of the SQL statement that generated this */
405 void *pFree
; /* Free this when deleting the vdbe */
406 VdbeFrame
*pFrame
; /* Parent frame */
407 VdbeFrame
*pDelFrame
; /* List of frame objects to free on VM reset */
408 int nFrame
; /* Number of frames in pFrame list */
409 u32 expmask
; /* Binding to these vars invalidates VM */
410 SubProgram
*pProgram
; /* Linked list of all sub-programs used by VM */
411 AuxData
*pAuxData
; /* Linked list of auxdata allocations */
412 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
413 i64
*anExec
; /* Number of times each op has been executed */
414 int nScan
; /* Entries in aScan[] */
415 ScanStatus
*aScan
; /* Scan definitions for sqlite3_stmt_scanstatus() */
420 ** The following are allowed values for Vdbe.magic
422 #define VDBE_MAGIC_INIT 0x16bceaa5 /* Building a VDBE program */
423 #define VDBE_MAGIC_RUN 0x2df20da3 /* VDBE is ready to execute */
424 #define VDBE_MAGIC_HALT 0x319c2973 /* VDBE has completed execution */
425 #define VDBE_MAGIC_RESET 0x48fa9f76 /* Reset and ready to run again */
426 #define VDBE_MAGIC_DEAD 0x5606c3c8 /* The VDBE has been deallocated */
429 ** Structure used to store the context required by the
430 ** sqlite3_preupdate_*() API functions.
434 VdbeCursor
*pCsr
; /* Cursor to read old values from */
435 int op
; /* One of SQLITE_INSERT, UPDATE, DELETE */
436 u8
*aRecord
; /* old.* database record */
438 UnpackedRecord
*pUnpacked
; /* Unpacked version of aRecord[] */
439 UnpackedRecord
*pNewUnpacked
; /* Unpacked version of new.* record */
440 int iNewReg
; /* Register for new.* values */
441 i64 iKey1
; /* First key value passed to hook */
442 i64 iKey2
; /* Second key value passed to hook */
443 Mem
*aNew
; /* Array of new.* values */
444 Table
*pTab
; /* Schema object being upated */
445 Index
*pPk
; /* PK index if pTab is WITHOUT ROWID */
449 ** Function prototypes
451 void sqlite3VdbeError(Vdbe
*, const char *, ...);
452 void sqlite3VdbeFreeCursor(Vdbe
*, VdbeCursor
*);
453 void sqliteVdbePopStack(Vdbe
*,int);
454 int sqlite3VdbeCursorMoveto(VdbeCursor
**, int*);
455 int sqlite3VdbeCursorRestore(VdbeCursor
*);
456 u32
sqlite3VdbeSerialTypeLen(u32
);
457 u8
sqlite3VdbeOneByteSerialTypeLen(u8
);
458 u32
sqlite3VdbeSerialType(Mem
*, int, u32
*);
459 u32
sqlite3VdbeSerialPut(unsigned char*, Mem
*, u32
);
460 u32
sqlite3VdbeSerialGet(const unsigned char*, u32
, Mem
*);
461 void sqlite3VdbeDeleteAuxData(sqlite3
*, AuxData
**, int, int);
463 int sqlite2BtreeKeyCompare(BtCursor
*, const void *, int, int, int *);
464 int sqlite3VdbeIdxKeyCompare(sqlite3
*,VdbeCursor
*,UnpackedRecord
*,int*);
465 int sqlite3VdbeIdxRowid(sqlite3
*, BtCursor
*, i64
*);
466 int sqlite3VdbeExec(Vdbe
*);
467 int sqlite3VdbeList(Vdbe
*);
468 int sqlite3VdbeHalt(Vdbe
*);
469 int sqlite3VdbeChangeEncoding(Mem
*, int);
470 int sqlite3VdbeMemTooBig(Mem
*);
471 int sqlite3VdbeMemCopy(Mem
*, const Mem
*);
472 void sqlite3VdbeMemShallowCopy(Mem
*, const Mem
*, int);
473 void sqlite3VdbeMemMove(Mem
*, Mem
*);
474 int sqlite3VdbeMemNulTerminate(Mem
*);
475 int sqlite3VdbeMemSetStr(Mem
*, const char*, int, u8
, void(*)(void*));
476 void sqlite3VdbeMemSetInt64(Mem
*, i64
);
477 #ifdef SQLITE_OMIT_FLOATING_POINT
478 # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
480 void sqlite3VdbeMemSetDouble(Mem
*, double);
482 void sqlite3VdbeMemSetPointer(Mem
*, void*, const char*, void(*)(void*));
483 void sqlite3VdbeMemInit(Mem
*,sqlite3
*,u16
);
484 void sqlite3VdbeMemSetNull(Mem
*);
485 void sqlite3VdbeMemSetZeroBlob(Mem
*,int);
486 void sqlite3VdbeMemSetRowSet(Mem
*);
487 int sqlite3VdbeMemMakeWriteable(Mem
*);
488 int sqlite3VdbeMemStringify(Mem
*, u8
, u8
);
489 i64
sqlite3VdbeIntValue(Mem
*);
490 int sqlite3VdbeMemIntegerify(Mem
*);
491 double sqlite3VdbeRealValue(Mem
*);
492 int sqlite3VdbeBooleanValue(Mem
*, int ifNull
);
493 void sqlite3VdbeIntegerAffinity(Mem
*);
494 int sqlite3VdbeMemRealify(Mem
*);
495 int sqlite3VdbeMemNumerify(Mem
*);
496 void sqlite3VdbeMemCast(Mem
*,u8
,u8
);
497 int sqlite3VdbeMemFromBtree(BtCursor
*,u32
,u32
,Mem
*);
498 void sqlite3VdbeMemRelease(Mem
*p
);
499 int sqlite3VdbeMemFinalize(Mem
*, FuncDef
*);
500 #ifndef SQLITE_OMIT_WINDOWFUNC
501 int sqlite3VdbeMemAggValue(Mem
*, Mem
*, FuncDef
*);
503 const char *sqlite3OpcodeName(int);
504 int sqlite3VdbeMemGrow(Mem
*pMem
, int n
, int preserve
);
505 int sqlite3VdbeMemClearAndResize(Mem
*pMem
, int n
);
506 int sqlite3VdbeCloseStatement(Vdbe
*, int);
507 void sqlite3VdbeFrameDelete(VdbeFrame
*);
508 int sqlite3VdbeFrameRestore(VdbeFrame
*);
509 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
510 void sqlite3VdbePreUpdateHook(Vdbe
*,VdbeCursor
*,int,const char*,Table
*,i64
,int);
512 int sqlite3VdbeTransferError(Vdbe
*p
);
514 int sqlite3VdbeSorterInit(sqlite3
*, int, VdbeCursor
*);
515 void sqlite3VdbeSorterReset(sqlite3
*, VdbeSorter
*);
516 void sqlite3VdbeSorterClose(sqlite3
*, VdbeCursor
*);
517 int sqlite3VdbeSorterRowkey(const VdbeCursor
*, Mem
*);
518 int sqlite3VdbeSorterNext(sqlite3
*, const VdbeCursor
*);
519 int sqlite3VdbeSorterRewind(const VdbeCursor
*, int *);
520 int sqlite3VdbeSorterWrite(const VdbeCursor
*, Mem
*);
521 int sqlite3VdbeSorterCompare(const VdbeCursor
*, Mem
*, int, int *);
524 void sqlite3VdbeIncrWriteCounter(Vdbe
*, VdbeCursor
*);
525 void sqlite3VdbeAssertAbortable(Vdbe
*);
527 # define sqlite3VdbeIncrWriteCounter(V,C)
528 # define sqlite3VdbeAssertAbortable(V)
531 #if !defined(SQLITE_OMIT_SHARED_CACHE)
532 void sqlite3VdbeEnter(Vdbe
*);
534 # define sqlite3VdbeEnter(X)
537 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
538 void sqlite3VdbeLeave(Vdbe
*);
540 # define sqlite3VdbeLeave(X)
544 void sqlite3VdbeMemAboutToChange(Vdbe
*,Mem
*);
545 int sqlite3VdbeCheckMemInvariants(Mem
*);
548 #ifndef SQLITE_OMIT_FOREIGN_KEY
549 int sqlite3VdbeCheckFk(Vdbe
*, int);
551 # define sqlite3VdbeCheckFk(p,i) 0
555 void sqlite3VdbePrintSql(Vdbe
*);
556 void sqlite3VdbeMemPrettyPrint(Mem
*pMem
, char *zBuf
);
558 #ifndef SQLITE_OMIT_UTF16
559 int sqlite3VdbeMemTranslate(Mem
*, u8
);
560 int sqlite3VdbeMemHandleBom(Mem
*pMem
);
563 #ifndef SQLITE_OMIT_INCRBLOB
564 int sqlite3VdbeMemExpandBlob(Mem
*);
565 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
567 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
568 #define ExpandBlob(P) SQLITE_OK
571 #endif /* !defined(SQLITE_VDBEINT_H) */