Lines Matching refs:Vdbe
8188 ** A single VDBE is an opaque structure named "Vdbe". Only routines
8192 typedef struct Vdbe Vdbe;
8288 ** is made. That copy is freed when the Vdbe is finalized. But if the
8290 ** gets freed when the Vdbe is finalized so it still should be obtained
8298 ** The Vdbe.aColName array contains 5n Mem structures, where n is the
8523 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3*);
8524 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe*,int);
8525 SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe*,int,int);
8526 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe*,int,int,int);
8527 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
8528 SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
8529 SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
8530 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp);
8531 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
8532 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
8533 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
8534 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
8535 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
8536 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
8537 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr);
8538 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
8539 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe*, int);
8540 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*, int);
8541 SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe*);
8542 SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe*);
8543 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe*);
8544 SQLITE_PRIVATE void sqlite3VdbeDeleteObject(sqlite3*,Vdbe*);
8545 SQLITE_PRIVATE void sqlite3VdbeMakeReady(Vdbe*,Parse*);
8546 SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe*);
8547 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe*, int);
8548 SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe*);
8550 SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *, int);
8551 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe*,FILE*);
8553 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe*);
8554 SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe*);
8555 SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe*);
8556 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe*,int);
8557 SQLITE_PRIVATE int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
8558 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe*);
8559 SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe*);
8560 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
8561 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe*,Vdbe*);
8562 SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*);
8563 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe*, int, u8);
8564 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe*, int);
8566 SQLITE_PRIVATE char *sqlite3VdbeExpandSql(Vdbe*, const char*);
8574 SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
8579 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe*, const char*, ...);
8581 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe*, const char*, ...);
9479 struct Vdbe *pVdbe; /* List of active virtual machines */
10784 ** A Vdbe sub-program that implements the body and WHEN clause of trigger
10832 Vdbe *pVdbe; /* An engine for executing database bytecode */
10891 Vdbe *pReprepare; /* VM being reprepared (sqlite3Reprepare()) */
11399 SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int);
11428 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*);
11445 SQLITE_PRIVATE void sqlite3ExprCodeIsNullJump(Vdbe*, const Expr*, int, int);
11577 SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *, Index *);
11578 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *, Table *);
11643 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *, Table *, int, int);
11739 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe*, const char*, int);
11741 SQLITE_PRIVATE int sqlite3Reprepare(Vdbe*);
11848 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe*);
12620 ** Vdbe.cacheCtr. Vdbe.cacheCtr will never take on the value of
12627 u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
12639 ** values stored in the Vdbe struct. When the sub-program is finished,
12640 ** these values are copied back to the Vdbe from the VdbeFrame structure,
12647 ** is linked into the Vdbe.pDelFrame list. The contents of the Vdbe.pDelFrame
12653 ** The currently executing frame is stored in Vdbe.pFrame. Vdbe.pFrame is
12658 Vdbe *v; /* VM this frame belongs to */
12664 VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
12670 int nChange; /* Statement changes (Vdbe.nChanges) */
12809 ** The Vdbe.inVtabMethod variable is set to non-zero for the duration of
12817 struct Vdbe {
12834 Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
12876 ** The following are allowed values for Vdbe.magic
12886 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
12887 void sqliteVdbePopStack(Vdbe*,int);
12902 SQLITE_PRIVATE int sqlite3VdbeExec(Vdbe*);
12903 SQLITE_PRIVATE int sqlite3VdbeList(Vdbe*);
12904 SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe*);
12938 SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *, int);
12962 SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe*);
12963 SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe*);
12970 SQLITE_PRIVATE void sqlite3VdbeMemPrepareToChange(Vdbe*,Mem*);
12974 SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *, int);
12981 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe*);
13184 struct Vdbe *pVdbe; /* Used to iterate through VMs */
57742 SQLITE_PRIVATE void sqlite3VdbeMemPrepareToChange(Vdbe *pVdbe, Mem *pMem){
58340 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(sqlite3 *db){
58341 Vdbe *p;
58342 p = sqlite3DbMallocZero(db, sizeof(Vdbe) );
58358 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
58373 Vdbe *p = (Vdbe *)pStmt;
58380 SQLITE_PRIVATE void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
58381 Vdbe tmp, *pTmp;
58402 SQLITE_PRIVATE void sqlite3VdbeTrace(Vdbe *p, FILE *trace){
58408 ** Resize the Vdbe.aOp array so that it is at least one op larger than
58412 ** SQLITE_NOMEM. In this case Vdbe.aOp and Vdbe.nOpAlloc remain
58414 ** correctly deallocated along with the rest of the Vdbe).
58416 static int growOpArray(Vdbe *p){
58443 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
58474 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
58477 SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
58480 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
58489 Vdbe *p, /* Add the opcode to this VM */
58509 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
58520 Vdbe *p, /* Add the opcode to this VM */
58546 SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Vdbe *p){
58567 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *p, int x){
58579 SQLITE_PRIVATE void sqlite3VdbeRunOnlyOnce(Vdbe *p){
58587 ** in a Vdbe main program and each of the sub-programs (triggers) it may
58594 ** sIter.v = v; // v is of type Vdbe*
58603 Vdbe *v; /* Vdbe to iterate through the opcodes of */
58610 Vdbe *v = p->v;
58673 SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
58713 ** sqlite3VdbeMakeReady() to size the Vdbe.apArg[] array.
58717 static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
58763 SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){
58770 ** the Vdbe passed as the first argument. It is the callers responsibility
58776 ** the number of entries in the Vdbe.apArg[] array required to execute the
58779 SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg){
58796 SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
58838 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe *p, u32 addr, int val){
58849 SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe *p, u32 addr, int val){
58859 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
58870 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 val){
58882 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe *p, int addr){
58969 ** list at Vdbe.pSubProgram. This list is used to delete all sub-program
58972 SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
58980 SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
59003 ** sqlite3_malloc, to be freed when the Vdbe is finalized.
59006 ** caller should not free the allocation, it will be freed when the Vdbe is
59011 ** the Vdbe. In these cases we can just copy the pointer.
59015 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
59089 SQLITE_PRIVATE void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
59102 SQLITE_PRIVATE void sqlite3VdbeNoopComment(Vdbe *p, const char *zFormat, ...){
59139 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){
59268 ** Declare to the Vdbe that the BTree object at db->aDb[i] is used.
59274 SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
59305 SQLITE_PRIVATE void sqlite3VdbeEnter(Vdbe *p){
59327 SQLITE_PRIVATE void sqlite3VdbeLeave(Vdbe *p){
59441 Vdbe *p /* The VDBE */
59487 nSub = pSub->n/sizeof(Vdbe*);
59626 SQLITE_PRIVATE void sqlite3VdbePrintSql(Vdbe *p){
59643 SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
59713 SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){
59760 ** the Vdbe from the Parse object that helped generate it so that the
59761 ** the Vdbe becomes an independent entity and the Parse object can be
59768 Vdbe *p, /* The VDBE */
59873 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *p, VdbeCursor *pCx){
59897 ** Copy the values stored in the VdbeFrame structure to its Vdbe. This
59902 Vdbe *v = pFrame->v;
59917 ** Also release any dynamic memory held by the VM in the Vdbe.aMem memory
59922 static void closeAllCursors(Vdbe *p){
59958 static void Cleanup(Vdbe *p){
59962 /* Execute assert() statements to ensure that the Vdbe.apCsr[] and
59963 ** Vdbe.aMem[] arrays have already been cleaned up. */
59980 SQLITE_PRIVATE void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
60009 Vdbe *p, /* Vdbe being configured */
60036 static int vdbeCommit(sqlite3 *db, Vdbe *p){
60267 Vdbe *p;
60312 ** If the Vdbe passed as the first argument opened a statement-transaction,
60321 SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){
60325 /* If p->iStatement is greater than zero, then this Vdbe opened a
60386 SQLITE_PRIVATE int sqlite3VdbeCheckFk(Vdbe *p, int deferred){
60411 SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
60613 SQLITE_PRIVATE void sqlite3VdbeResetStepResult(Vdbe *p){
60628 SQLITE_PRIVATE int sqlite3VdbeReset(Vdbe *p){
60704 SQLITE_PRIVATE int sqlite3VdbeFinalize(Vdbe *p){
60734 ** Free all memory associated with the Vdbe passed as the second argument.
60736 ** VdbeDelete() also unlinks the Vdbe from the list of VMs associated with
60739 SQLITE_PRIVATE void sqlite3VdbeDeleteObject(sqlite3 *db, Vdbe *p){
60762 SQLITE_PRIVATE void sqlite3VdbeDelete(Vdbe *p){
61478 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
61493 Vdbe *p;
61500 ** Return the database associated with the Vdbe.
61502 SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){
61514 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetValue(Vdbe *v, int iVar, u8 aff){
61536 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
61573 Vdbe *p = (Vdbe*)pStmt;
61579 ** Check on a Vdbe to make sure it has not been finalized. Log
61583 static int vdbeSafety(Vdbe *p){
61591 static int vdbeSafetyNotNull(Vdbe *p){
61616 Vdbe *v = (Vdbe*)pStmt;
61646 Vdbe *v = (Vdbe*)pStmt;
61663 Vdbe *p = (Vdbe*)pStmt;
61665 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
61885 static int sqlite3Step(Vdbe *p){
62022 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
62214 Vdbe *pVm = (Vdbe *)pStmt;
62223 Vdbe *pVm = (Vdbe *)pStmt;
62236 Vdbe *pVm;
62239 pVm = (Vdbe *)pStmt;
62299 Vdbe *p = (Vdbe *)pStmt;
62402 Vdbe *p = (Vdbe *)pStmt;
62532 static int vdbeUnbind(Vdbe *p, int i){
62556 /* If the bit corresponding to this variable in Vdbe.expmask is set, then
62584 Vdbe *p = (Vdbe *)pStmt;
62621 Vdbe *p = (Vdbe *)pStmt;
62634 Vdbe *p = (Vdbe *)pStmt;
62644 Vdbe *p = (Vdbe*)pStmt;
62704 Vdbe *p = (Vdbe *)pStmt;
62718 Vdbe *p = (Vdbe*)pStmt;
62729 Vdbe *p = (Vdbe*)pStmt;
62741 SQLITE_PRIVATE int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
62757 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
62764 Vdbe *pFrom = (Vdbe*)pFromStmt;
62765 Vdbe *pTo = (Vdbe*)pToStmt;
62791 Vdbe *pFrom = (Vdbe*)pFromStmt;
62792 Vdbe *pTo = (Vdbe*)pToStmt;
62813 return pStmt ? ((Vdbe*)pStmt)->db : 0;
62821 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
62836 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
62846 Vdbe *pVdbe = (Vdbe*)pStmt;
62917 Vdbe *p, /* The prepared statement being evaluated */
63038 ** with 1 and going up to Vdbe.nMem. Each register can store
63202 Vdbe *p, /* The virtual machine */
63605 ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
63608 static void importVtabErrMsg(Vdbe *p, sqlite3_vtab *pVtab){
63649 Vdbe *p /* The VDBE */
63964 Vdbe *pVdbe;
66393 ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
66394 ** true (this flag is set if the Vdbe may modify more than one row and may
68272 Vdbe *pVdbe;
69863 Vdbe *v = (Vdbe *)p->pStmt;
69934 ** Code external to the Vdbe then "borrows" the b-tree cursor and
70063 Vdbe *v = (Vdbe *)pBlob->pStmt;
70129 if( pBlob && pBlob->pStmt ) sqlite3VdbeFinalize((Vdbe *)pBlob->pStmt);
70173 Vdbe *v;
70179 v = (Vdbe*)p->pStmt;
74292 Vdbe *v, /* The VDBE under construction */
74467 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
74599 Vdbe *v = sqlite3GetVdbe(pParse);
74821 Vdbe *v; /* Statement under construction */
74930 static char *dup8bytes(Vdbe *v, const char *in){
74947 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
74968 Vdbe *v = pParse->pVdbe;
75146 Vdbe *v, /* The VDBE under construction */
75179 Vdbe *v = pParse->pVdbe;
75268 ** Generate code into the current Vdbe to evaluate the given
75279 Vdbe *v = pParse->pVdbe; /* The VM under construction */
75932 Vdbe *v = pParse->pVdbe;
76184 Vdbe *v = pParse->pVdbe;
76304 Vdbe *v = pParse->pVdbe;
77110 Vdbe *v;
77182 Vdbe *v;
77372 Vdbe *v;
77527 Vdbe *v;
77661 Vdbe *v = sqlite3GetVdbe(pParse);
77719 Vdbe *v; /* The virtual machine being built up */
77978 Vdbe *v = sqlite3GetVdbe(pParse);
78639 Vdbe *v;
79236 Vdbe *pVdbe;
79264 Vdbe *v;
79733 Vdbe *v = sqlite3GetVdbe(p);
79869 Vdbe *v;
80443 Vdbe *v = pParse->pVdbe;
80651 Vdbe *v;
81039 Vdbe *v = sqlite3GetVdbe(pParse);
81148 Vdbe *v;
81467 Vdbe *v; /* Generate code into this virtual machine */
81961 Vdbe *v;
82090 Vdbe *v;
82529 Vdbe *v;
82555 Vdbe *v;
82575 Vdbe *v;
82597 Vdbe *v = sqlite3GetVdbe(pParse);
82669 Vdbe *v = sqlite3GetVdbe(pToplevel);
82766 Vdbe *v = sqlite3GetVdbe(pParse);
83626 Vdbe *v; /* The virtual database engine */
83888 Vdbe *v = pParse->pVdbe; /* Vdbe */
83892 /* Vdbe is guaranteed to have been allocated by this stage. */
84020 Vdbe *v = pParse->pVdbe;
85748 ** object (struct Vdbe). If, after the statement has run, its immediate
85986 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
86145 Vdbe *v = sqlite3GetVdbe(pParse);
86298 Vdbe *v = sqlite3GetVdbe(pParse);
86407 Vdbe *v = sqlite3GetVdbe(pParse);
86907 Vdbe *v;
86937 SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
86979 SQLITE_PRIVATE void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
87017 Vdbe *v = sqlite3GetVdbe(p);
87109 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
87160 Vdbe *v = pParse->pVdbe;
87326 Vdbe *v; /* Generate code into this virtual machine */
88031 Vdbe *v; /* VDBE under constrution */
88315 Vdbe *v;
88373 Vdbe *v;
88504 Vdbe *v; /* The VDBE we are building */
88826 sqlite3VdbeFinalize((Vdbe *)pStmt);
88834 rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
88850 if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
90107 Vdbe *v = sqlite3GetVdbe(pParse);
90169 Vdbe *v;
90276 Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
92013 Vdbe *pReprepare, /* VM being reprepared */
92137 Vdbe *pVdbe = pParse->pVdbe;
92173 Vdbe *pOld, /* VM being reprepared */
92203 SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){
92224 sqlite3VdbeSwap((Vdbe*)pNew, p);
92226 sqlite3VdbeResetStepResult((Vdbe*)pNew);
92227 sqlite3VdbeFinalize((Vdbe*)pNew);
92767 Vdbe *v = pParse->pVdbe;
92807 Vdbe *v, /* Generate code into this VM */
92837 Vdbe *v;
92893 Vdbe *v = pParse->pVdbe;
93158 Vdbe *v = pParse->pVdbe;
93203 Vdbe *v = pParse->pVdbe;
93225 Vdbe *v, /* Generate code into this VDBE */
93480 Vdbe *v = pParse->pVdbe;
93519 Vdbe *v = pParse->pVdbe;
93754 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
93755 Vdbe *v = pParse->pVdbe;
93787 Vdbe *v = 0;
93908 Vdbe *v; /* Generate code to this VDBE */
94281 Vdbe *v = pParse->pVdbe;
94500 Vdbe *v; /* Generate code to this VDBE */
95879 Vdbe *v = pParse->pVdbe;
95911 Vdbe *v = pParse->pVdbe;
95927 Vdbe *v = pParse->pVdbe;
96082 Vdbe *v; /* The virtual machine under construction */
97437 Vdbe *v;
97678 Vdbe *v;
97844 Vdbe *v = pParse->pVdbe;
97958 Vdbe *v; /* Temporary VM */
98102 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
98320 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
98359 Vdbe *v; /* The virtual database engine */
98865 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
98957 rc = sqlite3VdbeFinalize((Vdbe*)pStmt);
99015 Vdbe *v = sqlite3GetVdbe(pParse);
99630 Vdbe *v;
101032 Vdbe *pReprepare = pParse->pReprepare;
101055 Vdbe *v = pParse->pVdbe;
102331 Vdbe *v; /* Prepared statement under construction */
103756 Vdbe *v = pParse->pVdbe;
103802 Vdbe *v = pParse->pVdbe;
103897 Vdbe *v = pParse->pVdbe; /* The vm under construction */
104048 Vdbe *v = pParse->pVdbe; /* VM being constructed */
104135 Vdbe *v; /* The prepared stmt under constructions */
104909 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
105417 Vdbe *v = pParse->pVdbe;