Annotation of embedaddon/sqlite3/src/vdbeInt.h, revision 1.1
1.1 ! misho 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.
! 10: **
! 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.
! 17: */
! 18: #ifndef _VDBEINT_H_
! 19: #define _VDBEINT_H_
! 20:
! 21: /*
! 22: ** SQL is translated into a sequence of instructions to be
! 23: ** executed by a virtual machine. Each instruction is an instance
! 24: ** of the following structure.
! 25: */
! 26: typedef struct VdbeOp Op;
! 27:
! 28: /*
! 29: ** Boolean values
! 30: */
! 31: typedef unsigned char Bool;
! 32:
! 33: /* Opaque type used by code in vdbesort.c */
! 34: typedef struct VdbeSorter VdbeSorter;
! 35:
! 36: /* Opaque type used by the explainer */
! 37: typedef struct Explain Explain;
! 38:
! 39: /*
! 40: ** A cursor is a pointer into a single BTree within a database file.
! 41: ** The cursor can seek to a BTree entry with a particular key, or
! 42: ** loop over all entries of the Btree. You can also insert new BTree
! 43: ** entries or retrieve the key or data from the entry that the cursor
! 44: ** is currently pointing to.
! 45: **
! 46: ** Every cursor that the virtual machine has open is represented by an
! 47: ** instance of the following structure.
! 48: */
! 49: struct VdbeCursor {
! 50: BtCursor *pCursor; /* The cursor structure of the backend */
! 51: Btree *pBt; /* Separate file holding temporary table */
! 52: KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
! 53: int iDb; /* Index of cursor database in db->aDb[] (or -1) */
! 54: int pseudoTableReg; /* Register holding pseudotable content. */
! 55: int nField; /* Number of fields in the header */
! 56: Bool zeroed; /* True if zeroed out and ready for reuse */
! 57: Bool rowidIsValid; /* True if lastRowid is valid */
! 58: Bool atFirst; /* True if pointing to first entry */
! 59: Bool useRandomRowid; /* Generate new record numbers semi-randomly */
! 60: Bool nullRow; /* True if pointing to a row with no data */
! 61: Bool deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */
! 62: Bool isTable; /* True if a table requiring integer keys */
! 63: Bool isIndex; /* True if an index containing keys only - no data */
! 64: Bool isOrdered; /* True if the underlying table is BTREE_UNORDERED */
! 65: Bool isSorter; /* True if a new-style sorter */
! 66: sqlite3_vtab_cursor *pVtabCursor; /* The cursor for a virtual table */
! 67: const sqlite3_module *pModule; /* Module for cursor pVtabCursor */
! 68: i64 seqCount; /* Sequence counter */
! 69: i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */
! 70: i64 lastRowid; /* Last rowid from a Next or NextIdx operation */
! 71: VdbeSorter *pSorter; /* Sorter object for OP_SorterOpen cursors */
! 72:
! 73: /* Result of last sqlite3BtreeMoveto() done by an OP_NotExists or
! 74: ** OP_IsUnique opcode on this cursor. */
! 75: int seekResult;
! 76:
! 77: /* Cached information about the header for the data record that the
! 78: ** cursor is currently pointing to. Only valid if cacheStatus matches
! 79: ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
! 80: ** CACHE_STALE and so setting cacheStatus=CACHE_STALE guarantees that
! 81: ** the cache is out of date.
! 82: **
! 83: ** aRow might point to (ephemeral) data for the current row, or it might
! 84: ** be NULL.
! 85: */
! 86: u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
! 87: int payloadSize; /* Total number of bytes in the record */
! 88: u32 *aType; /* Type values for all entries in the record */
! 89: u32 *aOffset; /* Cached offsets to the start of each columns data */
! 90: u8 *aRow; /* Data for the current row, if all on one page */
! 91: };
! 92: typedef struct VdbeCursor VdbeCursor;
! 93:
! 94: /*
! 95: ** When a sub-program is executed (OP_Program), a structure of this type
! 96: ** is allocated to store the current value of the program counter, as
! 97: ** well as the current memory cell array and various other frame specific
! 98: ** values stored in the Vdbe struct. When the sub-program is finished,
! 99: ** these values are copied back to the Vdbe from the VdbeFrame structure,
! 100: ** restoring the state of the VM to as it was before the sub-program
! 101: ** began executing.
! 102: **
! 103: ** The memory for a VdbeFrame object is allocated and managed by a memory
! 104: ** cell in the parent (calling) frame. When the memory cell is deleted or
! 105: ** overwritten, the VdbeFrame object is not freed immediately. Instead, it
! 106: ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
! 107: ** list is deleted when the VM is reset in VdbeHalt(). The reason for doing
! 108: ** this instead of deleting the VdbeFrame immediately is to avoid recursive
! 109: ** calls to sqlite3VdbeMemRelease() when the memory cells belonging to the
! 110: ** child frame are released.
! 111: **
! 112: ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
! 113: ** set to NULL if the currently executing frame is the main program.
! 114: */
! 115: typedef struct VdbeFrame VdbeFrame;
! 116: struct VdbeFrame {
! 117: Vdbe *v; /* VM this frame belongs to */
! 118: int pc; /* Program Counter in parent (calling) frame */
! 119: Op *aOp; /* Program instructions for parent frame */
! 120: int nOp; /* Size of aOp array */
! 121: Mem *aMem; /* Array of memory cells for parent frame */
! 122: int nMem; /* Number of entries in aMem */
! 123: u8 *aOnceFlag; /* Array of OP_Once flags for parent frame */
! 124: int nOnceFlag; /* Number of entries in aOnceFlag */
! 125: VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
! 126: u16 nCursor; /* Number of entries in apCsr */
! 127: void *token; /* Copy of SubProgram.token */
! 128: int nChildMem; /* Number of memory cells for child frame */
! 129: int nChildCsr; /* Number of cursors for child frame */
! 130: i64 lastRowid; /* Last insert rowid (sqlite3.lastRowid) */
! 131: int nChange; /* Statement changes (Vdbe.nChanges) */
! 132: VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */
! 133: };
! 134:
! 135: #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
! 136:
! 137: /*
! 138: ** A value for VdbeCursor.cacheValid that means the cache is always invalid.
! 139: */
! 140: #define CACHE_STALE 0
! 141:
! 142: /*
! 143: ** Internally, the vdbe manipulates nearly all SQL values as Mem
! 144: ** structures. Each Mem struct may cache multiple representations (string,
! 145: ** integer etc.) of the same value.
! 146: */
! 147: struct Mem {
! 148: sqlite3 *db; /* The associated database connection */
! 149: char *z; /* String or BLOB value */
! 150: double r; /* Real value */
! 151: union {
! 152: i64 i; /* Integer value used when MEM_Int is set in flags */
! 153: int nZero; /* Used when bit MEM_Zero is set in flags */
! 154: FuncDef *pDef; /* Used only when flags==MEM_Agg */
! 155: RowSet *pRowSet; /* Used only when flags==MEM_RowSet */
! 156: VdbeFrame *pFrame; /* Used when flags==MEM_Frame */
! 157: } u;
! 158: int n; /* Number of characters in string value, excluding '\0' */
! 159: u16 flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
! 160: u8 type; /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
! 161: u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
! 162: #ifdef SQLITE_DEBUG
! 163: Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
! 164: void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
! 165: #endif
! 166: void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
! 167: char *zMalloc; /* Dynamic buffer allocated by sqlite3_malloc() */
! 168: };
! 169:
! 170: /* One or more of the following flags are set to indicate the validOK
! 171: ** representations of the value stored in the Mem struct.
! 172: **
! 173: ** If the MEM_Null flag is set, then the value is an SQL NULL value.
! 174: ** No other flags may be set in this case.
! 175: **
! 176: ** If the MEM_Str flag is set then Mem.z points at a string representation.
! 177: ** Usually this is encoded in the same unicode encoding as the main
! 178: ** database (see below for exceptions). If the MEM_Term flag is also
! 179: ** set, then the string is nul terminated. The MEM_Int and MEM_Real
! 180: ** flags may coexist with the MEM_Str flag.
! 181: */
! 182: #define MEM_Null 0x0001 /* Value is NULL */
! 183: #define MEM_Str 0x0002 /* Value is a string */
! 184: #define MEM_Int 0x0004 /* Value is an integer */
! 185: #define MEM_Real 0x0008 /* Value is a real number */
! 186: #define MEM_Blob 0x0010 /* Value is a BLOB */
! 187: #define MEM_RowSet 0x0020 /* Value is a RowSet object */
! 188: #define MEM_Frame 0x0040 /* Value is a VdbeFrame object */
! 189: #define MEM_Invalid 0x0080 /* Value is undefined */
! 190: #define MEM_TypeMask 0x00ff /* Mask of type bits */
! 191:
! 192: /* Whenever Mem contains a valid string or blob representation, one of
! 193: ** the following flags must be set to determine the memory management
! 194: ** policy for Mem.z. The MEM_Term flag tells us whether or not the
! 195: ** string is \000 or \u0000 terminated
! 196: */
! 197: #define MEM_Term 0x0200 /* String rep is nul terminated */
! 198: #define MEM_Dyn 0x0400 /* Need to call sqliteFree() on Mem.z */
! 199: #define MEM_Static 0x0800 /* Mem.z points to a static string */
! 200: #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
! 201: #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
! 202: #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
! 203: #ifdef SQLITE_OMIT_INCRBLOB
! 204: #undef MEM_Zero
! 205: #define MEM_Zero 0x0000
! 206: #endif
! 207:
! 208: /*
! 209: ** Clear any existing type flags from a Mem and replace them with f
! 210: */
! 211: #define MemSetTypeFlag(p, f) \
! 212: ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f)
! 213:
! 214: /*
! 215: ** Return true if a memory cell is not marked as invalid. This macro
! 216: ** is for use inside assert() statements only.
! 217: */
! 218: #ifdef SQLITE_DEBUG
! 219: #define memIsValid(M) ((M)->flags & MEM_Invalid)==0
! 220: #endif
! 221:
! 222:
! 223: /* A VdbeFunc is just a FuncDef (defined in sqliteInt.h) that contains
! 224: ** additional information about auxiliary information bound to arguments
! 225: ** of the function. This is used to implement the sqlite3_get_auxdata()
! 226: ** and sqlite3_set_auxdata() APIs. The "auxdata" is some auxiliary data
! 227: ** that can be associated with a constant argument to a function. This
! 228: ** allows functions such as "regexp" to compile their constant regular
! 229: ** expression argument once and reused the compiled code for multiple
! 230: ** invocations.
! 231: */
! 232: struct VdbeFunc {
! 233: FuncDef *pFunc; /* The definition of the function */
! 234: int nAux; /* Number of entries allocated for apAux[] */
! 235: struct AuxData {
! 236: void *pAux; /* Aux data for the i-th argument */
! 237: void (*xDelete)(void *); /* Destructor for the aux data */
! 238: } apAux[1]; /* One slot for each function argument */
! 239: };
! 240:
! 241: /*
! 242: ** The "context" argument for a installable function. A pointer to an
! 243: ** instance of this structure is the first argument to the routines used
! 244: ** implement the SQL functions.
! 245: **
! 246: ** There is a typedef for this structure in sqlite.h. So all routines,
! 247: ** even the public interface to SQLite, can use a pointer to this structure.
! 248: ** But this file is the only place where the internal details of this
! 249: ** structure are known.
! 250: **
! 251: ** This structure is defined inside of vdbeInt.h because it uses substructures
! 252: ** (Mem) which are only defined there.
! 253: */
! 254: struct sqlite3_context {
! 255: FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */
! 256: VdbeFunc *pVdbeFunc; /* Auxilary data, if created. */
! 257: Mem s; /* The return value is stored here */
! 258: Mem *pMem; /* Memory cell used to store aggregate context */
! 259: int isError; /* Error code returned by the function. */
! 260: CollSeq *pColl; /* Collating sequence */
! 261: };
! 262:
! 263: /*
! 264: ** An Explain object accumulates indented output which is helpful
! 265: ** in describing recursive data structures.
! 266: */
! 267: struct Explain {
! 268: Vdbe *pVdbe; /* Attach the explanation to this Vdbe */
! 269: StrAccum str; /* The string being accumulated */
! 270: int nIndent; /* Number of elements in aIndent */
! 271: u16 aIndent[100]; /* Levels of indentation */
! 272: char zBase[100]; /* Initial space */
! 273: };
! 274:
! 275: /*
! 276: ** An instance of the virtual machine. This structure contains the complete
! 277: ** state of the virtual machine.
! 278: **
! 279: ** The "sqlite3_stmt" structure pointer that is returned by sqlite3_prepare()
! 280: ** is really a pointer to an instance of this structure.
! 281: **
! 282: ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
! 283: ** any virtual table method invocations made by the vdbe program. It is
! 284: ** set to 2 for xDestroy method calls and 1 for all other methods. This
! 285: ** variable is used for two purposes: to allow xDestroy methods to execute
! 286: ** "DROP TABLE" statements and to prevent some nasty side effects of
! 287: ** malloc failure when SQLite is invoked recursively by a virtual table
! 288: ** method function.
! 289: */
! 290: struct Vdbe {
! 291: sqlite3 *db; /* The database connection that owns this statement */
! 292: Op *aOp; /* Space to hold the virtual machine's program */
! 293: Mem *aMem; /* The memory locations */
! 294: Mem **apArg; /* Arguments to currently executing user function */
! 295: Mem *aColName; /* Column names to return */
! 296: Mem *pResultSet; /* Pointer to an array of results */
! 297: int nMem; /* Number of memory locations currently allocated */
! 298: int nOp; /* Number of instructions in the program */
! 299: int nOpAlloc; /* Number of slots allocated for aOp[] */
! 300: int nLabel; /* Number of labels used */
! 301: int nLabelAlloc; /* Number of slots allocated in aLabel[] */
! 302: int *aLabel; /* Space to hold the labels */
! 303: u16 nResColumn; /* Number of columns in one row of the result set */
! 304: u16 nCursor; /* Number of slots in apCsr[] */
! 305: u32 magic; /* Magic number for sanity checking */
! 306: char *zErrMsg; /* Error message written here */
! 307: Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
! 308: VdbeCursor **apCsr; /* One element of this array for each open cursor */
! 309: Mem *aVar; /* Values for the OP_Variable opcode. */
! 310: char **azVar; /* Name of variables */
! 311: ynVar nVar; /* Number of entries in aVar[] */
! 312: ynVar nzVar; /* Number of entries in azVar[] */
! 313: u32 cacheCtr; /* VdbeCursor row cache generation counter */
! 314: int pc; /* The program counter */
! 315: int rc; /* Value to return */
! 316: u8 errorAction; /* Recovery action to do in case of an error */
! 317: u8 explain; /* True if EXPLAIN present on SQL command */
! 318: u8 changeCntOn; /* True to update the change-counter */
! 319: u8 expired; /* True if the VM needs to be recompiled */
! 320: u8 runOnlyOnce; /* Automatically expire on reset */
! 321: u8 minWriteFileFormat; /* Minimum file format for writable database files */
! 322: u8 inVtabMethod; /* See comments above */
! 323: u8 usesStmtJournal; /* True if uses a statement journal */
! 324: u8 readOnly; /* True for read-only statements */
! 325: u8 isPrepareV2; /* True if prepared with prepare_v2() */
! 326: int nChange; /* Number of db changes made since last reset */
! 327: yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
! 328: yDbMask lockMask; /* Subset of btreeMask that requires a lock */
! 329: int iStatement; /* Statement number (or 0 if has not opened stmt) */
! 330: int aCounter[3]; /* Counters used by sqlite3_stmt_status() */
! 331: #ifndef SQLITE_OMIT_TRACE
! 332: i64 startTime; /* Time when query started - used for profiling */
! 333: #endif
! 334: i64 nFkConstraint; /* Number of imm. FK constraints this VM */
! 335: i64 nStmtDefCons; /* Number of def. constraints when stmt started */
! 336: char *zSql; /* Text of the SQL statement that generated this */
! 337: void *pFree; /* Free this when deleting the vdbe */
! 338: #ifdef SQLITE_DEBUG
! 339: FILE *trace; /* Write an execution trace here, if not NULL */
! 340: #endif
! 341: #ifdef SQLITE_ENABLE_TREE_EXPLAIN
! 342: Explain *pExplain; /* The explainer */
! 343: char *zExplain; /* Explanation of data structures */
! 344: #endif
! 345: VdbeFrame *pFrame; /* Parent frame */
! 346: VdbeFrame *pDelFrame; /* List of frame objects to free on VM reset */
! 347: int nFrame; /* Number of frames in pFrame list */
! 348: u32 expmask; /* Binding to these vars invalidates VM */
! 349: SubProgram *pProgram; /* Linked list of all sub-programs used by VM */
! 350: int nOnceFlag; /* Size of array aOnceFlag[] */
! 351: u8 *aOnceFlag; /* Flags for OP_Once */
! 352: };
! 353:
! 354: /*
! 355: ** The following are allowed values for Vdbe.magic
! 356: */
! 357: #define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */
! 358: #define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */
! 359: #define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */
! 360: #define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */
! 361:
! 362: /*
! 363: ** Function prototypes
! 364: */
! 365: void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
! 366: void sqliteVdbePopStack(Vdbe*,int);
! 367: int sqlite3VdbeCursorMoveto(VdbeCursor*);
! 368: #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
! 369: void sqlite3VdbePrintOp(FILE*, int, Op*);
! 370: #endif
! 371: u32 sqlite3VdbeSerialTypeLen(u32);
! 372: u32 sqlite3VdbeSerialType(Mem*, int);
! 373: u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
! 374: u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
! 375: void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
! 376:
! 377: int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
! 378: int sqlite3VdbeIdxKeyCompare(VdbeCursor*,UnpackedRecord*,int*);
! 379: int sqlite3VdbeIdxRowid(sqlite3*, BtCursor *, i64 *);
! 380: int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
! 381: int sqlite3VdbeExec(Vdbe*);
! 382: int sqlite3VdbeList(Vdbe*);
! 383: int sqlite3VdbeHalt(Vdbe*);
! 384: int sqlite3VdbeChangeEncoding(Mem *, int);
! 385: int sqlite3VdbeMemTooBig(Mem*);
! 386: int sqlite3VdbeMemCopy(Mem*, const Mem*);
! 387: void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
! 388: void sqlite3VdbeMemMove(Mem*, Mem*);
! 389: int sqlite3VdbeMemNulTerminate(Mem*);
! 390: int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
! 391: void sqlite3VdbeMemSetInt64(Mem*, i64);
! 392: #ifdef SQLITE_OMIT_FLOATING_POINT
! 393: # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64
! 394: #else
! 395: void sqlite3VdbeMemSetDouble(Mem*, double);
! 396: #endif
! 397: void sqlite3VdbeMemSetNull(Mem*);
! 398: void sqlite3VdbeMemSetZeroBlob(Mem*,int);
! 399: void sqlite3VdbeMemSetRowSet(Mem*);
! 400: int sqlite3VdbeMemMakeWriteable(Mem*);
! 401: int sqlite3VdbeMemStringify(Mem*, int);
! 402: i64 sqlite3VdbeIntValue(Mem*);
! 403: int sqlite3VdbeMemIntegerify(Mem*);
! 404: double sqlite3VdbeRealValue(Mem*);
! 405: void sqlite3VdbeIntegerAffinity(Mem*);
! 406: int sqlite3VdbeMemRealify(Mem*);
! 407: int sqlite3VdbeMemNumerify(Mem*);
! 408: int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
! 409: void sqlite3VdbeMemRelease(Mem *p);
! 410: void sqlite3VdbeMemReleaseExternal(Mem *p);
! 411: #define VdbeMemRelease(X) \
! 412: if((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame)) \
! 413: sqlite3VdbeMemReleaseExternal(X);
! 414: int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
! 415: const char *sqlite3OpcodeName(int);
! 416: int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
! 417: int sqlite3VdbeCloseStatement(Vdbe *, int);
! 418: void sqlite3VdbeFrameDelete(VdbeFrame*);
! 419: int sqlite3VdbeFrameRestore(VdbeFrame *);
! 420: void sqlite3VdbeMemStoreType(Mem *pMem);
! 421: int sqlite3VdbeTransferError(Vdbe *p);
! 422:
! 423: #ifdef SQLITE_OMIT_MERGE_SORT
! 424: # define sqlite3VdbeSorterInit(Y,Z) SQLITE_OK
! 425: # define sqlite3VdbeSorterWrite(X,Y,Z) SQLITE_OK
! 426: # define sqlite3VdbeSorterClose(Y,Z)
! 427: # define sqlite3VdbeSorterRowkey(Y,Z) SQLITE_OK
! 428: # define sqlite3VdbeSorterRewind(X,Y,Z) SQLITE_OK
! 429: # define sqlite3VdbeSorterNext(X,Y,Z) SQLITE_OK
! 430: # define sqlite3VdbeSorterCompare(X,Y,Z) SQLITE_OK
! 431: #else
! 432: int sqlite3VdbeSorterInit(sqlite3 *, VdbeCursor *);
! 433: void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *);
! 434: int sqlite3VdbeSorterRowkey(VdbeCursor *, Mem *);
! 435: int sqlite3VdbeSorterNext(sqlite3 *, VdbeCursor *, int *);
! 436: int sqlite3VdbeSorterRewind(sqlite3 *, VdbeCursor *, int *);
! 437: int sqlite3VdbeSorterWrite(sqlite3 *, VdbeCursor *, Mem *);
! 438: int sqlite3VdbeSorterCompare(VdbeCursor *, Mem *, int *);
! 439: #endif
! 440:
! 441: #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
! 442: void sqlite3VdbeEnter(Vdbe*);
! 443: void sqlite3VdbeLeave(Vdbe*);
! 444: #else
! 445: # define sqlite3VdbeEnter(X)
! 446: # define sqlite3VdbeLeave(X)
! 447: #endif
! 448:
! 449: #ifdef SQLITE_DEBUG
! 450: void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
! 451: #endif
! 452:
! 453: #ifndef SQLITE_OMIT_FOREIGN_KEY
! 454: int sqlite3VdbeCheckFk(Vdbe *, int);
! 455: #else
! 456: # define sqlite3VdbeCheckFk(p,i) 0
! 457: #endif
! 458:
! 459: int sqlite3VdbeMemTranslate(Mem*, u8);
! 460: #ifdef SQLITE_DEBUG
! 461: void sqlite3VdbePrintSql(Vdbe*);
! 462: void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
! 463: #endif
! 464: int sqlite3VdbeMemHandleBom(Mem *pMem);
! 465:
! 466: #ifndef SQLITE_OMIT_INCRBLOB
! 467: int sqlite3VdbeMemExpandBlob(Mem *);
! 468: #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
! 469: #else
! 470: #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
! 471: #define ExpandBlob(P) SQLITE_OK
! 472: #endif
! 473:
! 474: #endif /* !defined(_VDBEINT_H_) */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vdbeInt.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src