Lines Matching +full:3648 +full:v
2006 ** The second argument to sqlite3_db_config(D,V,...) is the
6013 ** ^If [sqlite3_value] object V was initialized
6016 ** then sqlite3_value_pointer(V,Y) will return the pointer P. ^Otherwise,
6017 ** sqlite3_value_pointer(V,Y) returns a NULL. The sqlite3_bind_pointer()
6020 ** ^(The sqlite3_value_type(V) interface returns the
6022 ** [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER],
6026 ** sqlite3_value_text(V) is called to extract a text value for that
6027 ** integer, then subsequent calls to sqlite3_value_type(V) might return
6130 ** The sqlite3_value_subtype(V) function returns the subtype for
6131 ** an [application-defined SQL function] argument V. The subtype
6148 ** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value]
6151 ** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a
6152 ** memory allocation fails. ^If V is a [pointer value], then the result
6153 ** of sqlite3_value_dup(V) is a NULL value.
6155 ** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object
6156 ** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer
6157 ** then sqlite3_value_free(V) is a harmless no-op.
8787 ** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf]
10449 ** ^When the sqlite3_vtab_rhs_value(P,J,V) interface is invoked from within
10453 ** attempts to set *V to the value of the right-hand operand of
10455 ** right-hand operand is not known, then *V is set to a NULL pointer.
10456 ** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
10457 ** and only if *V is set to a value. ^The sqlite3_vtab_rhs_value(P,J,V)
10473 ** ^The [sqlite3_value] object returned in *V is a protected sqlite3_value
10506 ** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a
10509 ** When the value returned to V is a string, space to hold that string is
10519 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be
10523 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be set
10527 ** <dd>^The "double" variable pointed to by the V parameter will be set to the
10535 ** <dd>^The "const char *" variable pointed to by the V parameter will be set
10540 ** <dd>^The "const char *" variable pointed to by the V parameter will be set
10545 ** <dd>^The "int" variable pointed to by the V parameter will be set to the
10551 ** <dd>The "int" variable pointed to by the V parameter will be set to the
15306 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) argument
15312 #define GLOBAL(t,v) v argument
16901 # define ExplainQueryPlan2(V,P) (V = sqlite3VdbeExplain P) argument
16903 # define ExplainQueryPlan2(V,P) ExplainQueryPlan(P) argument
16909 # define ExplainQueryPlan2(V,P) argument
17024 ** VdbeCoverage(v) // Mark the previously coded instruction
17027 ** VdbeCoverageIf(v, conditional) // Mark previous if conditional true
17029 ** VdbeCoverageAlwaysTaken(v) // Previous branch is always taken
17031 ** VdbeCoverageNeverTaken(v) // Previous branch is never taken
17033 ** VdbeCoverageNeverNull(v) // Previous three-way branch is only
17037 ** VdbeCoverageEqNe(v) // Previous OP_Jump is only interested
17058 # define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__) argument
17059 # define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__) argument
17060 # define VdbeCoverageAlwaysTaken(v) \ argument
17061 sqlite3VdbeSetLineNumber(v,__LINE__|0x5000000);
17062 # define VdbeCoverageNeverTaken(v) \ argument
17063 sqlite3VdbeSetLineNumber(v,__LINE__|0x6000000);
17064 # define VdbeCoverageNeverNull(v) \ argument
17065 sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000);
17066 # define VdbeCoverageNeverNullIf(v,x) \ argument
17067 if(x)sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000);
17068 # define VdbeCoverageEqNe(v) \ argument
17069 sqlite3VdbeSetLineNumber(v,__LINE__|0x8000000);
17072 # define VdbeCoverage(v) argument
17073 # define VdbeCoverageIf(v,x) argument
17074 # define VdbeCoverageAlwaysTaken(v) argument
17075 # define VdbeCoverageNeverTaken(v) argument
17076 # define VdbeCoverageNeverNull(v) argument
17077 # define VdbeCoverageNeverNullIf(v,x) argument
17078 # define VdbeCoverageEqNe(v) argument
21212 SQLITE_PRIVATE int sqlite3VarintLen(u64 v);
21455 #define sqlite3TableLock(v,w,x,y,z) argument
21562 #define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0) argument
23290 Vdbe *v; /* VM this frame belongs to */ member
23633 Vdbe *v; member
23788 # define sqlite3VdbeIncrWriteCounter(V,C) argument
23789 # define sqlite3VdbeAssertAbortable(V) argument
25592 ** %G ISO year corresponding to %V 0000-9999.
25593 ** %g 2-digit ISO year corresponding to %V 00-99
25611 ** %V week of year 01-53 (First week containing Thursday is week 01)
25746 case 'V': { /* Week num. 01-53. First week with a Thur is week 01 */ in strftimeFunc()
31521 i64 v; in sqlite3_str_vappendf() local
31523 v = getIntArg(pArgList); in sqlite3_str_vappendf()
31526 v = va_arg(ap,i64) ; in sqlite3_str_vappendf()
31528 v = va_arg(ap,long int); in sqlite3_str_vappendf()
31531 v = va_arg(ap,int); in sqlite3_str_vappendf()
31533 if( v<0 ){ in sqlite3_str_vappendf()
31534 testcase( v==SMALLEST_INT64 ); in sqlite3_str_vappendf()
31535 testcase( v==(-1) ); in sqlite3_str_vappendf()
31536 longvalue = ~v; in sqlite3_str_vappendf()
31540 longvalue = v; in sqlite3_str_vappendf()
35652 SQLITE_PRIVATE int sqlite3Int64ToText(i64 v, char *zOut){ in sqlite3Int64ToText() argument
35656 if( v<0 ){ in sqlite3Int64ToText()
35657 x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v; in sqlite3Int64ToText()
35659 x = v; in sqlite3Int64ToText()
35669 if( v<0 ) zTemp[--i] = '-'; in sqlite3Int64ToText()
35859 sqlite_int64 v = 0; in sqlite3GetInt32() local
35890 v = v*10 + c; in sqlite3GetInt32()
35902 testcase( v-neg==2147483647 ); in sqlite3GetInt32()
35903 if( v-neg>2147483647 ){ in sqlite3GetInt32()
35907 v = -v; in sqlite3GetInt32()
35909 *pValue = (int)v; in sqlite3GetInt32()
35939 u64 v; in sqlite3FpDecode() local
35958 memcpy(&v,&r,8); in sqlite3FpDecode()
35959 e = v>>52; in sqlite3FpDecode()
35961 p->isSpecial = 1 + (v!=0x7ff0000000000000LL); in sqlite3FpDecode()
35981 v = (u64)rr; in sqlite3FpDecode()
36022 v = rr[1]<0.0 ? (u64)rr[0]-(u64)(-rr[1]) : (u64)rr[0]+(u64)rr[1]; in sqlite3FpDecode()
36028 assert( v>0 ); in sqlite3FpDecode()
36029 while( v ){ p->zBuf[i--] = (v%10) + '0'; v /= 10; } in sqlite3FpDecode()
36077 u64 v = 0; in sqlite3GetUInt32() local
36080 v = v*10 + z[i] - '0'; in sqlite3GetUInt32()
36081 if( v>4294967296LL ){ *pI = 0; return 0; } in sqlite3GetUInt32()
36084 *pI = (u32)v; in sqlite3GetUInt32()
36117 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ in putVarint64() argument
36120 if( v & (((u64)0xff000000)<<32) ){ in putVarint64()
36121 p[8] = (u8)v; in putVarint64()
36122 v >>= 8; in putVarint64()
36124 p[i] = (u8)((v & 0x7f) | 0x80); in putVarint64()
36125 v >>= 7; in putVarint64()
36131 buf[n++] = (u8)((v & 0x7f) | 0x80); in putVarint64()
36132 v >>= 7; in putVarint64()
36133 }while( v!=0 ); in putVarint64()
36141 SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){ in sqlite3PutVarint() argument
36142 if( v<=0x7f ){ in sqlite3PutVarint()
36143 p[0] = v&0x7f; in sqlite3PutVarint()
36146 if( v<=0x3fff ){ in sqlite3PutVarint()
36147 p[0] = ((v>>7)&0x7f)|0x80; in sqlite3PutVarint()
36148 p[1] = v&0x7f; in sqlite3PutVarint()
36151 return putVarint64(p,v); in sqlite3PutVarint()
36169 ** Return the number of bytes read. The value is stored in *v.
36171 SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ in sqlite3GetVarint() argument
36175 *v = *p; in sqlite3GetVarint()
36179 *v = ((u32)(p[0]&0x7f)<<7) | p[1]; in sqlite3GetVarint()
36198 *v = a; in sqlite3GetVarint()
36215 *v = a; in sqlite3GetVarint()
36241 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36262 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36277 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36295 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36316 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36323 ** Return the number of bytes read. The value is stored in *v.
36326 ** integer, then set *v to 0xffffffff.
36332 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ in sqlite3GetVarint32() argument
36342 *v = ((p[0]&0x7f)<<7) | p[1]; in sqlite3GetVarint32()
36347 *v = ((p[0]&0x7f)<<14) | ((p[1]&0x7f)<<7) | p[2]; in sqlite3GetVarint32()
36354 *v = 0xffffffff; in sqlite3GetVarint32()
36356 *v = (u32)v64; in sqlite3GetVarint32()
36365 SQLITE_PRIVATE int sqlite3VarintLen(u64 v){ in sqlite3VarintLen() argument
36367 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); } in sqlite3VarintLen()
36393 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){ in sqlite3Put4byte() argument
36395 memcpy(p,&v,4); in sqlite3Put4byte()
36397 u32 x = __builtin_bswap32(v); in sqlite3Put4byte()
36400 u32 x = _byteswap_ulong(v); in sqlite3Put4byte()
36403 p[0] = (u8)(v>>24); in sqlite3Put4byte()
36404 p[1] = (u8)(v>>16); in sqlite3Put4byte()
36405 p[2] = (u8)(v>>8); in sqlite3Put4byte()
36406 p[3] = (u8)v; in sqlite3Put4byte()
54102 ** Let V[] be an array of unsigned characters sufficient to hold
54105 ** individual bits within V.
54107 #define SETBIT(V,I) V[I>>3] |= (1<<(I&7))
54108 #define CLEARBIT(V,I) V[I>>3] &= ~(1<<(I&7))
54109 #define TESTBIT(V,I) (V[I>>3]&(1<<(I&7)))!=0
56522 ** in the list, pLeft points to the tree, and v is unused. The
56526 i64 v; /* ROWID value for this entry */
56658 pEntry->v = rowid;
56662 if( rowid<=pLast->v ){ /*OPTIMIZATION-IF-FALSE*/
56690 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
56691 assert( pB->pRight==0 || pB->v<=pB->pRight->v );
56692 if( pA->v<=pB->v ){
56693 if( pA->v<pB->v ) pTail = pTail->pRight = pA;
56713 ** increasing v.
56861 *pRowid = p->pEntry->v;
56913 pTree->v = 0;
56931 if( p->v<iRowid ){
56933 }else if( p->v>iRowid ){
56999 # define sqlite3WalClose(v,w,x,y,z) 0
57008 # define sqlite3WalFrames(u,v,w,x,y,z) 0
57009 # define sqlite3WalCheckpoint(q,r,s,t,u,v,w,x,y,z) 0
57249 ** V | |
57252 ** | V |
57255 ** | V |
57258 ** | V |
57261 ** | V |
57832 # define PAGER_INCR(v) v++
57834 # define PAGER_INCR(v)
57942 # define pagerWalFrames(v,w,x,y) 0
69629 ** | | v
70229 #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v))
84610 Vdbe *v;
84613 if( (v = pParse->pReprepare)!=0 ){
84616 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
84790 sqlite3_value *v, /* Value to be set */
84796 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
84802 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){
84803 if( !v ) return;
84804 sqlite3VdbeMemRelease((Mem *)v);
84805 sqlite3DbFreeNN(((Mem*)v)->db, v);
85001 static int growOpArray(Vdbe *v, int nOp){
85003 Parse *p = v->pParse;
85013 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
85014 : (sqlite3_int64)v->nOpAlloc+nOp);
85016 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
85028 assert( nNew>=(v->nOpAlloc+nOp) );
85029 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
85032 v->nOpAlloc = p->szOpAlloc/sizeof(Op);
85033 v->aOp = pNew;
85284 Vdbe *v = pParse->pVdbe;
85288 assert( v );
85301 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
85302 addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
85304 sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
85365 Vdbe *v;
85371 v = pParse->pVdbe;
85372 iThis = v->nOp;
85373 addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
85375 sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetLastOp(v)->p4.z);
85379 sqlite3VdbeScanStatus(v, iThis, -1, -1, 0, 0);
85411 SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
85412 sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
85420 v->pParse->nTempReg = 0;
85421 v->pParse->nRangeReg = 0;
85458 static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
85473 p->aLabel[j] = v->nOp;
85476 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){
85477 Parse *p = v->pParse;
85479 assert( v->eVdbeState==VDBE_INIT_STATE );
85484 printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
85488 resizeResolveLabel(p,v,j);
85491 p->aLabel[j] = v->nOp;
85526 ** sIter.v = v; // v is of type Vdbe*
85530 ** sqlite3DbFree(v->db, sIter.apSub);
85535 Vdbe *v; /* Vdbe to iterate through the opcodes of */
85542 Vdbe *v = p->v;
85550 aOp = v->aOp;
85551 nOp = v->nOp;
85572 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
85608 SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
85617 if( v==0 ) return 0;
85619 sIter.v = v;
85650 sqlite3DbFree(v->db, sIter.apSub);
85657 return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter
85831 Vdbe *v, /* The byte-code program under construction */
85840 assert( v!=0 );
85841 pParse = v->pParse;
85845 assert( iLast<v->nOp );
85846 pOp = &v->aOp[iFirst];
85866 for(; j<v->nOp; j++){
85867 VdbeOp *pX = &v->aOp[j];
85890 sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_INTERNAL, OE_Abort, 0, zErr, 0);
86456 Vdbe *v = pParse->pVdbe;
86458 assert( v!=0 );
86461 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
86503 SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){
86504 sqlite3VdbeGetLastOp(v)->iSrcLine = iLine;
87064 pFrame->pParent = pFrame->v->pDelFrame;
87065 pFrame->v->pDelFrame = pFrame;
87194 if( apCsr[i] ) sqlite3VdbeFreeCursorNN(p->v, apCsr[i]);
87197 sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0);
87198 sqlite3DbFree(p->v->db, p);
87623 Vdbe *v = pFrame->v;
87624 closeCursorsInFrame(v);
87625 v->aOp = pFrame->aOp;
87626 v->nOp = pFrame->nOp;
87627 v->aMem = pFrame->aMem;
87628 v->nMem = pFrame->nMem;
87629 v->apCsr = pFrame->apCsr;
87630 v->nCursor = pFrame->nCursor;
87631 v->db->lastRowid = pFrame->lastRowid;
87632 v->nChange = pFrame->nChange;
87633 v->db->nChange = pFrame->nDbChange;
87634 sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0);
87635 v->pAuxData = pFrame->pAuxData;
88362 static void vdbeInvokeSqllog(Vdbe *v){
88363 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
88364 char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql);
88365 assert( v->db->init.busy==0 );
88368 sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1
88370 sqlite3DbFree(v->db, zExpanded);
89787 i64 v;
89847 v = pPKey2->u.i;
89848 if( v>lhs ){
89850 }else if( v<lhs ){
90003 Mem m, v;
90052 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
90053 *rowid = v.u.i;
90121 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
90122 v->changeCntOn = 1;
90153 SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){
90154 return v->db;
90160 SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe *v){
90161 return v->prepFlags;
90166 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
90172 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){
90174 if( v ){
90175 Mem *pMem = &v->aVar[iVar-1];
90176 assert( (v->db->flags & SQLITE_EnableQPSG)==0
90177 || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
90179 sqlite3_value *pRet = sqlite3ValueNew(v->db);
90195 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
90197 assert( (v->db->flags & SQLITE_EnableQPSG)==0
90198 || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
90200 v->expmask |= 0x80000000;
90202 v->expmask |= ((u32)1 << (iVar-1));
90302 Vdbe *v, /* Vdbe pre-update hook is invoked by */
90311 sqlite3 *db = v->db;
90334 iKey2 = v->aMem[iReg].u.i;
90346 preupdate.v = v;
90483 Vdbe *v = (Vdbe*)pStmt;
90484 sqlite3 *db = v->db;
90485 if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
90487 checkProfileCallback(db, v);
90488 assert( v->eVdbeState>=VDBE_READY_STATE );
90489 rc = sqlite3VdbeReset(v);
90490 sqlite3VdbeDelete(v);
90510 Vdbe *v = (Vdbe*)pStmt;
90511 sqlite3 *db = v->db;
90513 checkProfileCallback(db, v);
90514 rc = sqlite3VdbeReset(v);
90515 sqlite3VdbeRewind(v);
91274 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
91278 if( vdbeSafetyNotNull(v) ){
91281 db = v->db;
91283 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
91285 int savedPc = v->pc;
91286 rc = sqlite3Reprepare(v);
91297 sqlite3DbFree(db, v->zErrMsg);
91299 v->zErrMsg = sqlite3DbStrDup(db, zErr);
91300 v->rc = rc = sqlite3ApiExit(db, rc);
91302 v->zErrMsg = 0;
91303 v->rc = rc = SQLITE_NOMEM_BKPT;
91313 v->minWriteFileFormat = 254;
91315 assert( v->expired==0 );
92364 Vdbe *v = (Vdbe*)pStmt;
92369 sqlite3_mutex_enter(v->db->mutex);
92370 if( ((int)v->explain)==eMode ){
92374 }else if( (v->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
92376 }else if( v->eVdbeState!=VDBE_READY_STATE ){
92378 }else if( v->nMem>=10 && (eMode!=2 || v->haveEqpOps) ){
92380 v->explain = eMode;
92383 v->explain = eMode;
92384 rc = sqlite3Reprepare(v);
92385 v->haveEqpOps = eMode==2;
92387 if( v->explain ){
92388 v->nResColumn = 12 - 4*v->explain;
92390 v->nResColumn = v->nResAlloc;
92392 sqlite3_mutex_leave(v->db->mutex);
92400 Vdbe *v = (Vdbe*)pStmt;
92401 return v!=0 && v->eVdbeState==VDBE_RUN_STATE;
92433 u32 v;
92445 v = 0;
92446 db->pnBytesFreed = (int*)&v;
92454 v = pVdbe->aCounter[op];
92457 return (int)v;
92634 return (p ? p->v->nFrame : 0);
92687 Mem *pData = &p->v->aMem[p->iNewReg];
92723 rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]);
93247 static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){
93251 (void)v;
93731 SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){
93733 for(i=1; i<v->nMem; i++) registerTrace(i, v->aMem+i);
96759 u64 v;
96761 assert( sizeof(v)==sizeof(pRec->u.r) );
96762 memcpy(&v, &pRec->u.r, sizeof(v));
96763 swapMixedEndianFloat(v);
96765 v = pRec->u.i;
96770 default: zPayload[7] = (u8)(v&0xff); v >>= 8;
96771 zPayload[6] = (u8)(v&0xff); v >>= 8;
96773 case 6: zPayload[5] = (u8)(v&0xff); v >>= 8;
96774 zPayload[4] = (u8)(v&0xff); v >>= 8;
96776 case 4: zPayload[3] = (u8)(v&0xff); v >>= 8;
96778 case 3: zPayload[2] = (u8)(v&0xff); v >>= 8;
96780 case 2: zPayload[1] = (u8)(v&0xff); v >>= 8;
96782 case 1: zPayload[0] = (u8)(v&0xff);
97205 ** Often, v-tables store their data in other SQLite tables, which
97206 ** are queried from within xNext() and other v-table methods using
97209 ** v-table would have to be ready for the sqlite3_vtab structure itself
97211 ** a v-table method.
98609 i64 v; /* The new rowid */
98618 v = 0;
98659 v = 1; /* IMP: R-61914-48074 */
98662 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98663 if( v>=MAX_ROWID ){
98666 v++; /* IMP: R-29538-34987 */
98695 if( v<pMem->u.i+1 ){
98696 v = pMem->u.i + 1;
98698 pMem->u.i = v;
98710 sqlite3_randomness(sizeof(v), &v);
98711 v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */
98712 }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
98721 assert( v>0 ); /* EV: R-40812-03570 */
98726 pOut->u.i = v;
99175 i64 v;
99188 v = pC->movetoTarget;
99195 rc = pModule->xRowid(pC->uc.pVCur, &v);
99208 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
99210 pOut->u.i = v;
100473 pFrame->v = p;
102340 Vdbe *v = (Vdbe *)p->pStmt;
102345 sqlite3VdbeMemSetInt64(&v->aMem[1], iRow);
102351 if( v->pc>4 ){
102352 v->pc = 4;
102353 assert( v->aOp[v->pc].opcode==OP_NotExists );
102354 rc = sqlite3VdbeExec(v);
102359 VdbeCursor *pC = v->apCsr[0];
102557 Vdbe *v = (Vdbe *)pBlob->pStmt;
102561 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
102564 sqlite3VdbeChangeP5(v, 1);
102565 assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed );
102566 aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
102569 sqlite3VdbeUsesBtree(v, iDb);
102580 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
102605 sqlite3VdbeMakeReady(v, &sParse);
102669 Vdbe *v;
102675 v = (Vdbe*)p->pStmt;
102680 }else if( v==0 ){
102689 assert( db == v->db );
102709 assert( v->apCsr[0]!=0 );
102710 assert( v->apCsr[0]->eCurType==CURTYPE_BTREE );
102712 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
102720 sqlite3VdbeFinalize(v);
102723 v->rc = rc;
109709 Vdbe *v = pParse->pVdbe;
109744 sqlite3VdbeAddOp2(v, OP_Integer, 1, dest);
109750 if( addrCmp ) sqlite3VdbeJumpHere(v, addrCmp);
109753 addrCmp = sqlite3VdbeCurrentAddr(v);
109755 testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
109756 testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
109757 testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
109758 testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
109759 testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
109760 testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
109764 addrCmp = sqlite3VdbeAddOp0(v, OP_ElseEq);
109765 testcase(opx==TK_LT); VdbeCoverageIf(v,opx==TK_LT);
109766 testcase(opx==TK_GT); VdbeCoverageIf(v,opx==TK_GT);
109769 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest);
109771 sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, dest, r2);
109777 sqlite3VdbeAddOp2(v, OP_NotNull, dest, addrDone); VdbeCoverage(v);
109780 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
109784 sqlite3VdbeJumpHere(v, addrCmp);
109785 sqlite3VdbeResolveLabel(v, addrDone);
109787 sqlite3VdbeAddOp2(v, OP_Not, dest, dest);
111323 u32 v;
111326 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
111329 ExprSetProperty(pExpr, v);
111823 int v = 0;
111824 if( sqlite3ExprIsInteger(p->pLeft, &v) ){
111825 assert( ((unsigned int)v)!=0x80000000 );
111826 *pValue = -v;
112008 static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){
112010 sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull);
112011 addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
112012 sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull);
112013 sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
112014 VdbeComment((v, "first_entry_in(%d)", iCur));
112015 sqlite3VdbeJumpHere(v, addr1);
112133 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
112176 assert(v); /* sqlite3GetVdbe() has always been previously called */
112179 int iAddr = sqlite3VdbeAddOp0(v, OP_Once);
112180 VdbeCoverage(v);
112186 sqlite3VdbeJumpHere(v, iAddr);
112263 int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
112266 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
112268 VdbeComment((v, "%s", pIdx->zName));
112275 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed,
112280 sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull);
112283 sqlite3VdbeJumpHere(v, iAddr);
112322 sqlite3SetHasNullFlag(v, iTab, rMayHaveNull);
112441 Vdbe *v; /* The prepared statement under construction */
112443 v = pParse->pVdbe;
112444 assert( v!=0 );
112462 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
112468 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
112471 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
112472 sqlite3VdbeJumpHere(v, addrOnce);
112482 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
112484 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
112495 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
112498 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
112500 VdbeComment((v, "RHS of IN operator"));
112584 sqlite3VdbeChangeToNoop(v, addrOnce-1);
112585 sqlite3VdbeChangeToNoop(v, addrOnce);
112592 sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
112593 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1);
112599 sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
112602 sqlite3VdbeAddOp1(v, OP_NullRow, iTab);
112603 sqlite3VdbeJumpHere(v, addrOnce);
112606 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112608 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112610 VdbeCoverage(v);
112642 Vdbe *v = pParse->pVdbe;
112643 assert( v!=0 );
112656 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
112667 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
112680 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
112695 sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, -1);
112703 sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
112704 VdbeComment((v, "Init subquery result"));
112707 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm);
112708 VdbeComment((v, "Init EXISTS result"));
112736 sqlite3VdbeJumpHere(v, addrOnce);
112738 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
112742 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
112744 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
112746 VdbeCoverage(v);
112810 Vdbe *v; /* Statement under construction */
112839 v = pParse->pVdbe;
112840 assert( v!=0 ); /* OOM detected prior to this routine */
112841 VdbeNoopComment((v, "begin IN expr"));
112884 sqlite3VdbeAddOp3(v, OP_Copy, rLhsOrig+i, rLhs+aiMap[i], 0);
112906 sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull);
112911 sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull);
112916 sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2,
112918 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq);
112919 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq);
112920 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_NotNull);
112921 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull);
112922 sqlite3VdbeChangeP5(v, zAff[0]);
112926 sqlite3VdbeAddOp4(v, op, rLhs, destIfFalse, r2,
112928 VdbeCoverageIf(v, op==OP_Ne);
112929 VdbeCoverageIf(v, op==OP_IsNull);
112930 sqlite3VdbeChangeP5(v, zAff[0] | SQLITE_JUMPIFNULL);
112934 sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v);
112935 sqlite3VdbeGoto(v, destIfFalse);
112937 sqlite3VdbeResolveLabel(v, labelOk);
112955 sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2);
112956 VdbeCoverage(v);
112968 sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs);
112969 VdbeCoverage(v);
112970 addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto); /* Return True */
112972 sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector);
112975 sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse,
112976 rLhs, nVector); VdbeCoverage(v);
112980 addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0,
112981 rLhs, nVector); VdbeCoverage(v);
112988 sqlite3VdbeAddOp2(v, OP_NotNull, rRhsHasNull, destIfFalse);
112989 VdbeCoverage(v);
112995 if( destIfFalse==destIfNull ) sqlite3VdbeGoto(v, destIfFalse);
113004 if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6);
113005 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse);
113006 VdbeCoverage(v);
113020 sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3);
113021 sqlite3VdbeAddOp4(v, OP_Ne, rLhs+i, destNotNull, r3,
113023 VdbeCoverage(v);
113026 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
113028 sqlite3VdbeResolveLabel(v, destNotNull);
113029 sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1);
113030 VdbeCoverage(v);
113034 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
113038 sqlite3VdbeJumpHere(v, addrTruthOp);
113042 VdbeComment((v, "end IN expr"));
113058 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
113064 sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL);
113077 Vdbe *v = pParse->pVdbe;
113082 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
113100 codeReal(v, z, negFlag, iMem);
113105 sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64);
113146 Vdbe *v = pParse->pVdbe;
113148 assert( v!=0 );
113151 iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
113157 sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1);
113159 if( iAddr ) sqlite3VdbeJumpHere(v, iAddr);
113168 Vdbe *v, /* Parsing context */
113175 assert( v!=0 );
113179 sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
113180 VdbeComment((v, "%s.rowid", pTab->zName));
113189 Parse *pParse = sqlite3VdbeParser(v);
113212 sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut);
113213 sqlite3ColumnDefault(v, pTab, iCol, regOut);
113306 static void setDoNotMergeFlagOnCopy(Vdbe *v){
113307 if( sqlite3VdbeGetLastOp(v)->opcode==OP_Copy ){
113308 sqlite3VdbeChangeP5(v, 1); /* Tag trailing OP_Copy as not mergeable */
113323 Vdbe *v = pParse->pVdbe;
113324 assert( v!=0 );
113339 sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
113340 VdbeCoverage(v);
113343 setDoNotMergeFlagOnCopy(v);
113344 sqlite3VdbeResolveLabel(v, endCoalesce);
113358 sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target);
113360 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
113382 sqlite3VdbeAddOp2(v, OP_Integer,
113391 sqlite3VdbeAddOp2(v, OP_Integer,
113403 sqlite3VdbeAddOp2(v, OP_Integer,
113407 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
113424 sqlite3VdbeLoadString(v, target,
113445 Vdbe *v;
113465 v = pParse->pVdbe;
113466 assert( v!=0 );
113471 int addr = sqlite3VdbeCurrentAddr(v);
113472 sqlite3VdbeAddOp3(v, OP_IfNullRow, p->iIdxCur, addr+3, target);
113473 VdbeCoverage(v);
113474 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
113475 VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));
113476 sqlite3VdbeGoto(v, 0);
113481 sqlite3VdbeJumpHere(v, addr+2);
113483 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
113484 VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));
113506 Vdbe *v = pParse->pVdbe;
113511 addr = sqlite3VdbeAddOp1(v, OP_IfNullRow, p->iIdxCur);
113517 sqlite3VdbeJumpHere(v, addr);
113518 sqlite3VdbeChangeP3(v, addr, ret);
113539 Vdbe *v = pParse->pVdbe; /* The VM under construction */
113549 assert( v!=0 );
113573 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
113577 sqlite3VdbeAddOp3(v, OP_NotNull, target, 1, 20230325);
113578 VdbeCoverageNeverTaken(v);
113587 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
113592 VdbeComment((v,"%s.rowid",pTab->zName));
113594 VdbeComment((v,"%s.%s",
113597 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
113604 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
113629 sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0,
113673 sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target);
113674 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
113702 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
113708 codeReal(v, pExpr->u.zToken, 0, target);
113714 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
113723 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
113737 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
113738 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
113746 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
113758 sqlite3VdbeAddOp2(v, OP_Cast, target,
113780 sqlite3VdbeAddOp2(v, OP_Integer, 1, inReg);
113782 sqlite3VdbeCurrentAddr(v)+2, p5,
113784 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
113785 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
113786 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
113787 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
113788 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
113789 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
113791 sqlite3VdbeAddOp2(v, OP_Integer, 0, inReg);
113793 sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, inReg, r2);
113825 sqlite3VdbeAddOp3(v, op, r2, r1, target);
113839 codeReal(v, pLeft->u.zToken, 1, target);
113849 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
113860 sqlite3VdbeAddOp2(v, op, r1, inReg);
113872 sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal);
113880 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
113883 addr = sqlite3VdbeAddOp1(v, op, r1);
113884 VdbeCoverageIf(v, op==TK_ISNULL);
113885 VdbeCoverageIf(v, op==TK_NOTNULL);
113886 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
113887 sqlite3VdbeJumpHere(v, addr);
114016 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
114065 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
114067 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
114068 sqlite3VdbeResolveLabel(v, destIfFalse);
114069 sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
114070 sqlite3VdbeResolveLabel(v, destIfNull);
114101 sqlite3VdbeAddOp1(v, OP_ClrSubtype, target);
114155 sqlite3VdbeAddOp2(v, OP_Param, p1, target);
114156 VdbeComment((v, "r[%d]=%s.%s", target,
114168 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
114196 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
114203 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
114215 sqlite3VdbeJumpHere(v, addrINR);
114290 sqlite3VdbeGoto(v, endLabel);
114291 sqlite3VdbeResolveLabel(v, nextCase);
114296 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
114299 setDoNotMergeFlagOnCopy(v);
114300 sqlite3VdbeResolveLabel(v, endLabel);
114321 v, OP_Halt, SQLITE_OK, OE_Ignore, 0, pExpr->u.zToken,0);
114322 VdbeCoverage(v);
114377 Vdbe *v = pParse->pVdbe;
114379 assert( v );
114380 addr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
114388 sqlite3VdbeJumpHere(v, addr);
114522 Vdbe *v = pParse->pVdbe;
114541 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
114552 && (pOp=sqlite3VdbeGetLastOp(v))->opcode==OP_Copy
114559 sqlite3VdbeAddOp2(v, copyOp, inReg, target+i);
114660 Vdbe *v = pParse->pVdbe;
114667 if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */
114683 sqlite3VdbeResolveLabel(v, d2);
114732 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
114733 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
114734 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
114735 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
114737 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ);
114738 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ);
114740 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ);
114741 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ);
114751 sqlite3VdbeTypeofColumn(v, r1);
114752 sqlite3VdbeAddOp2(v, op, r1, dest);
114753 VdbeCoverageIf(v, op==TK_ISNULL);
114754 VdbeCoverageIf(v, op==TK_NOTNULL);
114768 sqlite3VdbeGoto(v, dest);
114769 sqlite3VdbeResolveLabel(v, destIfFalse);
114776 sqlite3VdbeGoto(v, dest);
114781 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
114782 VdbeCoverage(v);
114803 Vdbe *v = pParse->pVdbe;
114810 if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */
114861 sqlite3VdbeResolveLabel(v, d2);
114909 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
114910 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
114911 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
114912 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
114914 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ);
114915 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ);
114917 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ);
114918 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ);
114926 sqlite3VdbeTypeofColumn(v, r1);
114927 sqlite3VdbeAddOp2(v, op, r1, dest);
114928 testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL);
114929 testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL);
114945 sqlite3VdbeResolveLabel(v, destIfNull);
114953 sqlite3VdbeGoto(v, dest);
114958 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
114959 VdbeCoverage(v);
116254 Vdbe *v = pParse->pVdbe;
116255 if( v ){
116278 Vdbe *v;
116279 VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */
116346 v = sqlite3GetVdbe(pParse);
116347 if( v==0 ){
116412 ** of any resources used by the v-table implementation (including other
116418 sqlite3VdbeLoadString(v, i, zName);
116419 sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
116465 Vdbe *v; /* The prepared statement under construction */
116570 v = sqlite3GetVdbe(pParse);
116571 if( v ){
116577 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
116578 sqlite3VdbeUsesBtree(v, iDb);
116579 sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);
116580 sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);
116581 VdbeCoverage(v);
116582 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
118376 Vdbe *v = sqlite3GetVdbe(pParse);
118379 addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
118382 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg);
118388 sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1);
118405 sqlite3VdbeAddOp2(v, OP_Null, 0, regOut);
118411 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
118420 sqlite3VdbeAddOp2(v, OP_Null, 0, reg+1);
118423 sqlite3VdbeAddOp3(v, OP_MakeRecord, reg+1, nField, regRec);
118425 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol);
118427 sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg);
118429 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
118431 sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v);
118432 sqlite3VdbeJumpHere(v, addr);
118644 Vdbe *v = sqlite3GetVdbe(pParse);
118653 if( v==0 ) return;
118655 assert( sqlite3VdbeDb(v)==db );
118694 sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
118702 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
118703 sqlite3VdbeChangeP5(v, aCreateTbl[i]);
118704 VdbeComment((v, aTable[i].zName));
119408 Vdbe *v, /* Prepared statement under construction */
119416 VdbeComment((v,"%s.rowid",pIdx->zName));
119419 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
119421 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
119444 Vdbe *v; /* The virtual machine being built up */
119468 v = sqlite3GetVdbe(pParse);
119469 if( v==0 || NEVER(pTab==0) ){
119512 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
119534 sqlite3VdbeLoadString(v, regIdxname, zIdxName);
119535 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
119582 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
119584 VdbeComment((v, "%s", pIdx->zName));
119599 sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
119606 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
119608 sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid);
119609 sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp,
119613 addrGotoEnd = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
119614 VdbeCoverage(v);
119616 sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng);
119617 addrNextRow = sqlite3VdbeCurrentAddr(v);
119635 sqlite3VdbeAddOp0(v, OP_Goto);
119636 addrNextRow = sqlite3VdbeCurrentAddr(v);
119641 sqlite3VdbeAddOp2(v, OP_NotNull, regPrev, endDistinctTest);
119642 VdbeCoverage(v);
119646 sqlite3VdbeAddOp2(v, OP_Integer, i, regChng);
119647 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regTemp);
119648 analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
119650 sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ);
119651 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
119652 VdbeCoverage(v);
119654 sqlite3VdbeAddOp2(v, OP_Integer, nColTest, regChng);
119655 sqlite3VdbeGoto(v, endDistinctTest);
119665 sqlite3VdbeJumpHere(v, addrNextRow-1);
119667 sqlite3VdbeJumpHere(v, aGotoChng[i]);
119668 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regPrev+i);
119669 analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
119671 sqlite3VdbeResolveLabel(v, endDistinctTest);
119686 sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, regRowid);
119694 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j);
119695 analyzeVdbeCommentIndexWithColumnName(v,pIdx,k);
119697 sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid);
119708 j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regTemp); VdbeCoverage(v);
119709 j2 = sqlite3VdbeAddOp1(v, OP_If, regTemp); VdbeCoverage(v);
119710 j3 = sqlite3VdbeAddOp4Int(v, OP_SeekGT, iIdxCur, 0, regPrev, 1);
119711 VdbeCoverage(v);
119712 sqlite3VdbeJumpHere(v, j1);
119713 sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
119714 sqlite3VdbeJumpHere(v, j2);
119715 sqlite3VdbeJumpHere(v, j3);
119717 sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
119725 sqlite3VdbeJumpHere(v, addrGotoEnd);
119730 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
119731 sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
119732 sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
119734 sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
119736 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
119753 sqlite3VdbeAddOp2(v, OP_Cast, regStat1, SQLITE_AFF_INTEGER);
119754 addrGotoEnd = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1);
119755 VdbeCoverage(v);
119788 addrNext = sqlite3VdbeCurrentAddr(v);
119790 addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid);
119791 VdbeCoverage(v);
119795 sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0);
119796 VdbeCoverage(v);
119800 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
119801 sqlite3VdbeAddOp3(v, OP_MakeRecord, regTabname, 6, regTemp);
119802 sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
119803 sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regTemp, regNewRowid);
119804 sqlite3VdbeAddOp2(v, OP_Goto, 1, addrNext); /* P1==1 for end-of-loop */
119805 sqlite3VdbeJumpHere(v, addrIsNull);
119810 if( addrGotoEnd ) sqlite3VdbeJumpHere(v, addrGotoEnd);
119818 VdbeComment((v, "%s", pTab->zName));
119819 sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1);
119820 jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v);
119821 sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);
119823 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
119824 sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
119825 sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
119826 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
119828 sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
119830 sqlite3VdbeJumpHere(v, jZeroRows);
119840 Vdbe *v = sqlite3GetVdbe(pParse);
119841 if( v ){
119842 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
119920 Vdbe *v;
119955 if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
119956 sqlite3VdbeAddOp0(v, OP_Expire);
119985 tRowcnt v;
119993 v = 0;
119995 v = v*10 + c - '0';
119999 if( aOut ) aOut[i] = v;
120000 if( aLog ) aLog[i] = sqlite3LogEst(v);
120005 aLog[i] = sqlite3LogEst(v);
120829 Vdbe *v;
120864 v = sqlite3GetVdbe(pParse);
120870 assert( v || db->mallocFailed );
120871 if( v ){
120878 sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
121509 Vdbe *v;
121525 v = pParse->pVdbe;
121526 if( v==0 ){
121531 v = sqlite3GetVdbe(pParse);
121532 if( v==0 ) pParse->rc = SQLITE_ERROR;
121535 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
121536 if( v ){
121543 sqlite3VdbeAddOp0(v, OP_FkCheck);
121545 sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
121546 VdbeCoverage(v);
121549 sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
121551 sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);
121552 sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
121553 VdbeCoverage(v);
121554 sqlite3VdbeJumpHere(v, addrRewind);
121557 sqlite3VdbeAddOp0(v, OP_Halt);
121576 assert( pParse->nErr>0 || sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
121577 sqlite3VdbeJumpHere(v, 0);
121583 sqlite3VdbeUsesBtree(v, iDb);
121585 sqlite3VdbeAddOp4Int(v,
121592 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
121593 VdbeComment((v,
121599 sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
121630 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);
121635 sqlite3VdbeGoto(v, 1);
121640 assert( v!=0 || pParse->nErr );
121646 sqlite3VdbeMakeReady(v, pParse);
122296 Vdbe *v = sqlite3GetVdbe(p);
122298 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
122510 ** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
122512 ** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
122556 Vdbe *v = sqlite3GetVdbe(pParse);
122557 if( v ){
122558 sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
122559 sqlite3VdbeUsesBtree(v, 0);
122591 Vdbe *v;
122700 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
122710 sqlite3VdbeAddOp0(v, OP_VBegin);
122720 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
122721 sqlite3VdbeUsesBtree(v, iDb);
122722 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
122725 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
122726 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
122727 sqlite3VdbeJumpHere(v, addr1);
122740 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
122746 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
122749 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
122750 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
122751 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
122752 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
122753 sqlite3VdbeAddOp0(v, OP_Close);
123059 int v = 0; /* default size is approx 4 bytes */
123065 sqlite3GetInt32(zChar, &v);
123071 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
123075 if( v>=sqlite3GlobalConfig.szSorterRef ){
123079 v = v/4 + 1;
123080 if( v>255 ) v = 255;
123081 pCol->szEst = v;
123418 Vdbe *v = pParse->pVdbe;
123420 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
123718 Vdbe *v = pParse->pVdbe;
123738 assert( v );
123739 sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY);
123800 if( v && pPk->tnum>0 ){
123802 sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
124152 Vdbe *v;
124157 v = sqlite3GetVdbe(pParse);
124158 if( NEVER(v==0) ) return;
124160 sqlite3VdbeAddOp1(v, OP_Close, 0);
124210 sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->regRoot, iDb);
124211 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
124212 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
124213 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
124226 sqlite3VdbeEndCoroutine(v, regYield);
124227 sqlite3VdbeJumpHere(v, addrTop - 1);
124228 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
124229 VdbeCoverage(v);
124230 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
124231 sqlite3TableAffinity(v, p, 0);
124232 sqlite3VdbeAddOp2(v, OP_NewRowid, iCsr, regRowid);
124233 sqlite3VdbeAddOp3(v, OP_Insert, iCsr, regRec, regRowid);
124234 sqlite3VdbeGoto(v, addrInsLoop);
124235 sqlite3VdbeJumpHere(v, addrInsLoop);
124236 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
124287 sqlite3VdbeAddParseSchemaOp(v, iDb,
124293 sqlite3VdbeAddOp4(v, OP_SqlExec, 0x0001, 0, 0,
124637 Vdbe *v = sqlite3GetVdbe(pParse);
124640 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
124739 Vdbe *v;
124744 v = sqlite3GetVdbe(pParse);
124745 assert( v!=0 );
124750 sqlite3VdbeAddOp0(v, OP_VBegin);
124799 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
124802 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
124848 Vdbe *v;
124936 v = sqlite3GetVdbe(pParse);
124937 if( v ){
125130 Vdbe *v; /* Generate code into this virtual machine */
125146 v = sqlite3GetVdbe(pParse);
125147 if( v==0 ) return;
125158 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
125164 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
125169 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
125171 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
125172 sqlite3VdbeJumpHere(v, addr1);
125173 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
125174 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
125176 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
125178 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
125180 int j2 = sqlite3VdbeGoto(v, 1);
125181 addr2 = sqlite3VdbeCurrentAddr(v);
125182 sqlite3VdbeVerifyAbortable(v, OE_Abort);
125183 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
125184 pIndex->nKeyCol); VdbeCoverage(v);
125186 sqlite3VdbeJumpHere(v, j2);
125196 addr2 = sqlite3VdbeCurrentAddr(v);
125198 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
125207 sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
125209 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
125210 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
125212 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
125213 sqlite3VdbeJumpHere(v, addr1);
125215 sqlite3VdbeAddOp1(v, OP_Close, iTab);
125216 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
125217 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
125774 Vdbe *v;
125778 v = sqlite3GetVdbe(pParse);
125779 if( v==0 ) goto exit_create_index;
125789 pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
125790 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
125826 sqlite3VdbeAddParseSchemaOp(v, iDb,
125828 sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
125831 sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
125947 Vdbe *v;
125993 v = sqlite3GetVdbe(pParse);
125994 if( v ){
126003 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
126501 Vdbe *v;
126510 v = sqlite3GetVdbe(pParse);
126511 if( !v ) return;
126523 sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType);
126524 sqlite3VdbeUsesBtree(v, i);
126527 sqlite3VdbeAddOp0(v, OP_AutoCommit);
126536 Vdbe *v;
126547 v = sqlite3GetVdbe(pParse);
126548 if( v ){
126549 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
126560 Vdbe *v = sqlite3GetVdbe(pParse);
126565 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
126569 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
126710 Vdbe *v;
126712 v = sqlite3GetVdbe(pParse);
126717 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
126718 sqlite3VdbeChangeP5(v, p5Errmsg);
127668 SQLITE_PRIVATE void sqlite3CodeChangeCount(Vdbe *v, int regCounter, const char *zColName){
127669 sqlite3VdbeAddOp0(v, OP_FkCheck);
127670 sqlite3VdbeAddOp2(v, OP_ResultRow, regCounter, 1);
127671 sqlite3VdbeSetNumCols(v, 1);
127672 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zColName, SQLITE_STATIC);
127910 Vdbe *v; /* The virtual database engine */
128032 v = sqlite3GetVdbe(pParse);
128033 if( v==0 ){
128036 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
128071 sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
128097 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
128103 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
128105 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
128119 sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
128129 addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk);
128149 sqlite3VdbeAddOp1(v, OP_FinishSeek, iTabCur);
128154 sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
128161 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
128167 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
128184 if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen);
128191 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey,
128193 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEphCur, iKey, iPk, nPk);
128197 sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey);
128210 iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
128218 sqlite3VdbeJumpHereOrPopInst(v, iAddrOnce);
128229 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);
128230 VdbeCoverage(v);
128233 addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v);
128235 sqlite3VdbeAddOp3(v, OP_Column, iEphCur, 0, iKey);
128237 sqlite3VdbeAddOp2(v, OP_RowData, iEphCur, iKey);
128241 addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey);
128242 VdbeCoverage(v);
128254 sqlite3VdbeAddOp1(v, OP_Close, iTabCur);
128259 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);
128260 sqlite3VdbeChangeP5(v, OE_Abort);
128271 sqlite3VdbeResolveLabel(v, addrBypass);
128274 sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v);
128275 sqlite3VdbeJumpHere(v, addrLoop);
128277 sqlite3VdbeGoto(v, addrLoop);
128278 sqlite3VdbeJumpHere(v, addrLoop);
128295 sqlite3CodeChangeCount(v, memCnt, "rows deleted");
128373 Vdbe *v = pParse->pVdbe; /* Vdbe */
128379 assert( v );
128380 VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)",
128389 sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
128390 VdbeCoverageIf(v, opSeek==OP_NotExists);
128391 VdbeCoverageIf(v, opSeek==OP_NotFound);
128412 sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld);
128418 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
128423 addrStart = sqlite3VdbeCurrentAddr(v);
128436 if( addrStart<sqlite3VdbeCurrentAddr(v) ){
128437 sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
128438 VdbeCoverageIf(v, opSeek==OP_NotExists);
128439 VdbeCoverageIf(v, opSeek==OP_NotFound);
128463 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
128465 sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE);
128468 sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);
128471 sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);
128474 sqlite3VdbeChangeP5(v, p5);
128492 sqlite3VdbeResolveLabel(v, iLabel);
128493 VdbeModuleComment((v, "END: GenRowDel()"));
128527 Vdbe *v; /* The prepared statement under construction */
128530 v = pParse->pVdbe;
128537 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
128540 sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,
128542 sqlite3VdbeChangeP5(v, 1); /* Cause IdxDelete to error if no entry found */
128589 Vdbe *v = pParse->pVdbe;
128626 sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
128630 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
128741 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
128743 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,
130231 const char *v = (const char*)sqlite3_value_text(argv[i]);
130232 if( v!=0 ){
130237 memcpy(&z[j], v, k);
131740 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
131744 sqlite3VdbeVerifyAbortable(v,
131758 sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
131759 VdbeCoverage(v);
131763 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v);
131778 sqlite3VdbeAddOp2(v, OP_SCopy,
131780 iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);
131781 VdbeCoverage(v);
131788 sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v);
131789 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
131793 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v);
131794 sqlite3VdbeGoto(v, iOk);
131795 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
131796 sqlite3VdbeJumpHere(v, iMustBeInt);
131802 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
131805 sqlite3VdbeAddOp2(v, OP_Copy,
131821 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
131834 sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v);
131835 sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
131837 sqlite3VdbeGoto(v, iOk);
131840 sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0,
131842 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);
131843 VdbeCoverage(v);
131863 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
131866 sqlite3VdbeResolveLabel(v, iOk);
131867 sqlite3VdbeAddOp1(v, OP_Close, iCur);
131971 Vdbe *v = sqlite3GetVdbe(pParse);
131979 iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
131980 VdbeCoverage(v);
132057 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
132066 sqlite3VdbeJumpHereOrPopInst(v, iFkIfZero);
132147 Vdbe *v = sqlite3GetVdbe(pParse);
132149 assert( v ); /* VDBE has already been allocated */
132163 sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v);
132180 sqlite3VdbeVerifyAbortable(v, OE_Abort);
132181 sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
132182 VdbeCoverage(v);
132188 sqlite3VdbeResolveLabel(v, iSkip);
132358 Vdbe *v = sqlite3GetVdbe(pParse);
132359 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
132364 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v);
132366 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
132926 Vdbe *v;
132929 v = pParse->pVdbe;
132936 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
132937 VdbeComment((v, "%s", pTab->zName));
132942 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
132944 VdbeComment((v, "%s", pTab->zName));
133072 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
133081 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
133082 pPrev = sqlite3VdbeGetLastOp(v);
133084 assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );
133086 sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3);
133089 sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
133090 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
133098 sqlite3OomFault(sqlite3VdbeDb(v));
133107 sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
133109 assert( sqlite3VdbeGetLastOp(v)->opcode==OP_MakeRecord
133110 || sqlite3VdbeDb(v)->mallocFailed );
133111 sqlite3VdbeChangeP4(v, -1, zColAff, i);
133123 Vdbe *v = sqlite3GetVdbe(p);
133125 int iEnd = sqlite3VdbeCurrentAddr(v);
133131 VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
133355 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
133362 assert( v ); /* We failed long ago if this is not so */
133384 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
133385 aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
133426 Vdbe *v = pParse->pVdbe;
133429 assert( v );
133446 sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
133447 VdbeCoverage(v);
133449 aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
133599 Vdbe *v = sqlite3GetVdbe(pParse);
133621 p->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
133625 sqlite3VdbeAddOp3(v,OP_InitCoroutine,p->regReturn,0,p->addrFillSub);
133781 Vdbe *v; /* Generate code into this virtual machine */
133890 v = sqlite3GetVdbe(pParse);
133891 if( v==0 ) goto insert_cleanup;
133892 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
134018 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
134019 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
134028 sqlite3VdbeEndCoroutine(v, regYield);
134029 sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
134065 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
134066 addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v);
134067 sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
134068 sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
134069 sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
134070 sqlite3VdbeGoto(v, addrL);
134071 sqlite3VdbeJumpHere(v, addrL);
134145 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
134208 addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v);
134209 addrCont = sqlite3VdbeCurrentAddr(v);
134220 addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
134221 VdbeCoverage(v);
134226 sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);
134248 sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
134265 sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
134300 sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore);
134303 sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore);
134309 sqlite3VdbeAddOp2(v,
134329 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
134334 sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols);
134339 addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v);
134340 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
134341 sqlite3VdbeJumpHere(v, addr1);
134342 sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
134347 sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
134367 sqlite3TableAffinity(v, pTab, regCols+1);
134380 sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
134385 sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid);
134391 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
134403 addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v);
134404 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
134405 sqlite3VdbeJumpHere(v, addr1);
134407 addr1 = sqlite3VdbeCurrentAddr(v);
134408 sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v);
134410 sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v);
134413 sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
134415 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
134437 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
134438 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
134460 bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v));
134470 sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
134477 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
134489 sqlite3VdbeResolveLabel(v, endOfLoop);
134491 sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
134492 sqlite3VdbeJumpHere(v, addrInsTop);
134493 sqlite3VdbeAddOp1(v, OP_Close, srcTab);
134495 sqlite3VdbeGoto(v, addrCont);
134500 if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){
134501 assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield );
134502 sqlite3VdbeChangeP5(v, 1);
134505 sqlite3VdbeJumpHere(v, addrInsTop);
134525 sqlite3CodeChangeCount(v, regRowCount, "rows inserted");
134783 Vdbe *v; /* VDBE under construction */
134811 v = pParse->pVdbe;
134812 assert( v!=0 );
134829 VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
134882 int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg);
134883 VdbeCoverage(v);
134888 sqlite3VdbeJumpHere(v, addr1);
134899 sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,
134901 sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
134902 sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
134903 VdbeCoverage(v);
134908 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest);
134909 VdbeCoverage(v);
134953 sqlite3TableAffinity(v, pTab, regNewData+1);
134957 sqlite3VdbeVerifyAbortable(v, onError);
134964 sqlite3VdbeGoto(v, ignoreDest);
134973 sqlite3VdbeResolveLabel(v, allOk);
135104 sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt);
135105 VdbeComment((v, "trigger count"));
135139 upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto);
135153 ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
135154 VdbeComment((v, "defer IPK REPLACE until last"));
135161 sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
135162 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
135163 VdbeCoverage(v);
135168 VdbeNoopComment((v, "uniqueness check for ROWID"));
135169 sqlite3VdbeVerifyAbortable(v, onError);
135170 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
135171 VdbeCoverage(v);
135214 sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
135223 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
135224 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
135242 sqlite3VdbeGoto(v, ignoreDest);
135246 sqlite3VdbeResolveLabel(v, addrRowidOk);
135248 upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto);
135250 ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
135251 sqlite3VdbeJumpHere(v, ipkTop-1);
135276 sqlite3VdbeJumpHere(v, upsertIpkDelay);
135281 sqlite3TableAffinity(v, pTab, regNewData+1);
135284 VdbeNoopComment((v, "prep index %s", pIdx->zName));
135290 sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
135308 VdbeComment((v, "%s column %d", pIdx->zName, i));
135311 sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i);
135312 VdbeComment((v, "rowid"));
135316 sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
135317 VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
135320 sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
135321 VdbeComment((v, "for %s", pIdx->zName));
135324 sqlite3SetMakeRecordP5(v, pIdx->pTable);
135334 sqlite3VdbeResolveLabel(v, addrUniqueOk);
135341 sqlite3VdbeResolveLabel(v, addrUniqueOk);
135379 sqlite3VdbeResolveLabel(v, addrUniqueOk);
135385 sqlite3VdbeVerifyAbortable(v, onError);
135387 sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
135388 regIdx, pIdx->nKeyCol); VdbeCoverage(v);
135394 sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
135398 sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
135399 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
135400 VdbeCoverage(v);
135410 sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
135411 VdbeComment((v, "%s.%s", pTab->zName,
135423 int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
135436 sqlite3VdbeAddOp4(v, op,
135439 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
135440 VdbeCoverageIf(v, op==OP_Eq);
135441 VdbeCoverageIf(v, op==OP_Ne);
135468 sqlite3VdbeGoto(v, ignoreDest);
135475 nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
135484 sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur);
135490 sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur);
135495 sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
135496 addrBypass = sqlite3VdbeAddOp0(v, OP_Goto); /* Bypass recheck */
135497 VdbeComment((v, "bypass recheck"));
135502 sqlite3VdbeResolveLabel(v, lblRecheckOk);
135507 sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk);
135508 VdbeCoverage(v);
135518 x = *sqlite3VdbeGetOp(v, addrConflictCk);
135528 sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type);
135529 sqlite3VdbeChangeP5(v, x.p5);
135530 VdbeCoverageIf(v, p2!=x.p2);
135538 sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */
135544 sqlite3VdbeResolveLabel(v, addrUniqueOk);
135550 sqlite3VdbeGoto(v, upsertIpkDelay+1);
135551 sqlite3VdbeJumpHere(v, upsertIpkReturn);
135558 sqlite3VdbeGoto(v, ipkTop);
135559 VdbeComment((v, "Do IPK REPLACE"));
135561 sqlite3VdbeJumpHere(v, ipkBottom);
135568 sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v);
135571 sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData);
135572 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
135573 VdbeCoverage(v);
135575 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData);
135576 VdbeCoverage(v);
135579 sqlite3VdbeGoto(v, addrRecheck);
135581 sqlite3VdbeResolveLabel(v, lblRecheckOk);
135587 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
135588 sqlite3SetMakeRecordP5(v, pTab);
135590 sqlite3TableAffinity(v, pTab, 0);
135595 VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
135605 SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
135616 sqlite3VdbeChangeP5(v, i+1);
135633 Vdbe *v = pParse->pVdbe;
135637 sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
135638 sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
135639 sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
135666 Vdbe *v; /* Prepared statements under construction */
135676 v = pParse->pVdbe;
135677 assert( v!=0 );
135686 sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
135687 VdbeCoverage(v);
135697 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
135700 sqlite3VdbeChangeP5(v, pik_flags);
135715 sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData);
135717 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
135719 sqlite3VdbeChangeP5(v, pik_flags);
135757 Vdbe *v;
135771 v = pParse->pVdbe;
135772 assert( v!=0 );
135790 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
135792 sqlite3VdbeChangeP5(v, p5);
135793 VdbeComment((v, "%s", pIdx->zName));
135903 Vdbe *v; /* The VDBE we are building */
136111 v = sqlite3GetVdbe(pParse);
136117 sqlite3VdbeAddOp2(v, OP_Null, 0, regData);
136143 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
136144 emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto);
136145 sqlite3VdbeJumpHere(v, addr1);
136150 emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
136152 addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
136154 sqlite3VdbeVerifyAbortable(v, onError);
136155 addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
136156 VdbeCoverage(v);
136158 sqlite3VdbeJumpHere(v, addr2);
136162 addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
136164 addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
136169 sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
136176 sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
136181 sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid);
136183 sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
136185 sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE);
136187 sqlite3VdbeChangeP5(v, insFlags);
136189 sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
136190 sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
136191 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
136202 sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
136204 VdbeComment((v, "%s", pSrcIdx->zName));
136205 sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
136207 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
136208 VdbeComment((v, "%s", pDestIdx->zName));
136209 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
136231 sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
136232 sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc);
136238 sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
136246 sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
136247 sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
136248 sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
136249 sqlite3VdbeJumpHere(v, addr1);
136250 sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
136251 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
136253 if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
136258 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
136259 sqlite3VdbeJumpHere(v, emptyDestTest);
136260 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
137141 # define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v;
137148 # define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */
138923 Vdbe *v, /* The query under construction */
138927 sqlite3VdbeSetNumCols(v, n==0 ? 1 : n);
138929 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
138933 sqlite3VdbeSetColName(v, i, COLNAME_NAME, pragCName[j], SQLITE_STATIC);
138941 static void returnSingleInt(Vdbe *v, i64 value){
138942 sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, 1, 0, (const u8*)&value, P4_INT64);
138943 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
138950 Vdbe *v, /* Prepared statement under construction */
138954 sqlite3VdbeLoadString(v, 1, (const char*)zValue);
138955 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
139057 Vdbe *v, /* The prepared statement being created */
139092 sqlite3VdbeMultiLoad(v, 1, "sissii",
139109 static int integrityCheckResultRow(Vdbe *v){
139111 sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
139112 addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);
139113 VdbeCoverage(v);
139114 sqlite3VdbeAddOp0(v, OP_Halt);
139149 Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */
139152 if( v==0 ) return;
139153 sqlite3VdbeRunOnlyOnce(v);
139205 sqlite3VdbeSetNumCols(v, 1);
139206 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, aFcntl[0], SQLITE_TRANSIENT);
139207 returnSingleText(v, aFcntl[0]);
139238 setPragmaResultColumnNames(v, pPragma);
139275 sqlite3VdbeUsesBtree(v, iDb);
139278 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize));
139279 aOp = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize, iLn);
139287 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
139311 returnSingleInt(v, size);
139350 returnSingleInt(v, b);
139377 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
139385 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
139387 sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
139433 returnSingleText(v, zRet);
139474 sqlite3VdbeUsesBtree(v, ii);
139475 sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
139478 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
139496 returnSingleInt(v, iLimit);
139514 returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt));
139540 int iAddr = sqlite3VdbeCurrentAddr(v);
139541 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6));
139542 aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
139549 sqlite3VdbeUsesBtree(v, iDb);
139568 sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
139569 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
139570 sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
139571 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
139572 sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v);
139573 sqlite3VdbeJumpHere(v, addr);
139593 returnSingleInt(v, pDb->pSchema->cache_size);
139627 returnSingleInt(v,
139681 returnSingleInt(v, sz);
139702 returnSingleInt(v, db->temp_store);
139722 returnSingleText(v, sqlite3_temp_directory);
139769 returnSingleText(v, sqlite3_data_directory);
139810 returnSingleText(v, proxy_file_path);
139842 returnSingleInt(v, pDb->safety_level-1);
139862 setPragmaResultColumnNames(v, pPragma);
139863 returnSingleInt(v, (db->flags & pPragma->iArg)!=0 );
139901 sqlite3VdbeAddOp0(v, OP_Expire);
139960 sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi",
140039 sqlite3VdbeMultiLoad(v, 1, "sssiii",
140060 sqlite3VdbeMultiLoad(v, 1, "ssiii",
140067 sqlite3VdbeMultiLoad(v, 2, "siiiX",
140072 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
140110 sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum,
140113 sqlite3VdbeMultiLoad(v, 4, "isiX",
140118 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem);
140135 sqlite3VdbeMultiLoad(v, 1, "isisi",
140152 sqlite3VdbeMultiLoad(v, 1, "iss",
140166 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
140181 pragmaFunclistLine(v, p, 1, showInternFunc);
140187 pragmaFunclistLine(v, p, 0, showInternFunc);
140198 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
140207 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
140230 sqlite3VdbeMultiLoad(v, 1, "iissssss",
140285 sqlite3VdbeLoadString(v, regResult, pTab->zName);
140297 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
140308 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
140327 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
140328 sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v);
140334 sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0,
140336 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol);
140337 VdbeCoverage(v);
140339 int jmp = sqlite3VdbeCurrentAddr(v)+2;
140340 sqlite3VdbeAddOp3(v, OP_SeekRowid, i, jmp, regRow); VdbeCoverage(v);
140341 sqlite3VdbeGoto(v, addrOk);
140347 sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1);
140349 sqlite3VdbeAddOp2(v, OP_Null, 0, regResult+1);
140351 sqlite3VdbeMultiLoad(v, regResult+2, "siX", pFK->zTo, i-1);
140352 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4);
140353 sqlite3VdbeResolveLabel(v, addrOk);
140356 sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v);
140357 sqlite3VdbeJumpHere(v, addrTop);
140439 sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */
140491 sqlite3VdbeAddOp4(v, OP_IntegrityCk, 1, cnt, 8, (char*)aRoot,P4_INTARRAY);
140492 sqlite3VdbeChangeP5(v, (u8)i);
140493 addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v);
140494 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
140497 sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 3);
140498 integrityCheckResultRow(v);
140499 sqlite3VdbeJumpHere(v, addr);
140503 sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
140520 addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+cnt, 0, 8+iTab);
140521 VdbeCoverageNeverNull(v);
140522 sqlite3VdbeLoadString(v, 4, pIdx->zName);
140523 sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3);
140524 integrityCheckResultRow(v);
140525 sqlite3VdbeJumpHere(v, addr);
140552 sqlite3VdbeAddOp3(v, OP_Null, 1, r2, r2+pPk->nKeyCol-1);
140559 sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
140561 sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */
140565 sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
140566 loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
140587 sqlite3VdbeAddOp3(v, OP_Column, iDataCur, mxCol, 3);
140588 sqlite3VdbeTypeofColumn(v, 3);
140596 a1 = sqlite3VdbeAddOp4Int(v, OP_IdxGT, iDataCur, 0,r2,pPk->nKeyCol);
140597 VdbeCoverage(v);
140598 sqlite3VdbeAddOp1(v, OP_IsNull, r2); VdbeCoverage(v);
140602 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
140603 integrityCheckResultRow(v);
140604 sqlite3VdbeJumpHere(v, a1);
140605 sqlite3VdbeJumpHere(v, a1+1);
140640 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
140668 int jmp2 = sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
140669 VdbeCoverage(v);
140671 sqlite3VdbeChangeP5(v, 0x0f); /* INT, REAL, TEXT, or BLOB */
140674 sqlite3VdbeChangeP5(v, 0x0d); /* INT, TEXT, or BLOB */
140679 sqlite3VdbeAddOp3(v, OP_Column, p1, p3, 3);
140680 sqlite3ColumnDefault(v, pTab, j, 3);
140681 jmp3 = sqlite3VdbeAddOp2(v, OP_NotNull, 3, labelOk);
140682 VdbeCoverage(v);
140686 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
140688 sqlite3VdbeGoto(v, labelError);
140689 sqlite3VdbeJumpHere(v, jmp2);
140690 sqlite3VdbeJumpHere(v, jmp3);
140705 sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
140707 sqlite3VdbeChangeP5(v, aStdTypeMask[pCol->eCType-1]);
140708 VdbeCoverage(v);
140712 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
140716 sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
140717 sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */
140718 VdbeCoverage(v);
140721 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
140725 sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
140726 sqlite3VdbeChangeP5(v, 0x1b); /* NULL, INT, FLOAT, or BLOB */
140727 VdbeCoverage(v);
140729 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
140731 sqlite3VdbeAddOp4(v, OP_Affinity, 3, 1, 0, "C", P4_STATIC);
140732 sqlite3VdbeAddOp4Int(v, OP_IsType, -1, labelOk, 3, p4);
140733 sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */
140734 VdbeCoverage(v);
140737 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
140739 sqlite3VdbeResolveLabel(v, labelError);
140740 integrityCheckResultRow(v);
140741 sqlite3VdbeResolveLabel(v, labelOk);
140757 sqlite3VdbeResolveLabel(v, addrCkFault);
140761 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
140762 integrityCheckResultRow(v);
140763 sqlite3VdbeResolveLabel(v, addrCkOk);
140777 sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);/* increment entry count */
140779 jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
140780 pIdx->nColumn); VdbeCoverage(v);
140781 sqlite3VdbeLoadString(v, 3, "row ");
140782 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
140783 sqlite3VdbeLoadString(v, 4, " missing from index ");
140784 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
140785 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
140786 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
140787 jmp4 = integrityCheckResultRow(v);
140788 sqlite3VdbeJumpHere(v, jmp2);
140796 sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur+j, 3);
140797 jmp7 = sqlite3VdbeAddOp3(v, OP_Eq, 3, 0, r1+pIdx->nColumn-1);
140798 VdbeCoverageNeverNull(v);
140799 sqlite3VdbeLoadString(v, 3,
140801 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
140802 sqlite3VdbeLoadString(v, 4, " of index ");
140803 sqlite3VdbeGoto(v, jmp5-1);
140804 sqlite3VdbeJumpHere(v, jmp7);
140813 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur+j, kk, 3);
140814 sqlite3VdbeAddOp3(v, OP_Ne, 3, label6, r1+kk); VdbeCoverage(v);
140817 int jmp6 = sqlite3VdbeAddOp0(v, OP_Goto);
140818 sqlite3VdbeResolveLabel(v, label6);
140819 sqlite3VdbeLoadString(v, 3, "row ");
140820 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
140821 sqlite3VdbeLoadString(v, 4, " values differ from index ");
140822 sqlite3VdbeGoto(v, jmp5-1);
140823 sqlite3VdbeJumpHere(v, jmp6);
140836 sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk);
140837 VdbeCoverage(v);
140839 jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
140840 sqlite3VdbeGoto(v, uniqOk);
140841 sqlite3VdbeJumpHere(v, jmp6);
140842 sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
140843 pIdx->nKeyCol); VdbeCoverage(v);
140844 sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
140845 sqlite3VdbeGoto(v, jmp5);
140846 sqlite3VdbeResolveLabel(v, uniqOk);
140848 sqlite3VdbeJumpHere(v, jmp4);
140852 sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
140853 sqlite3VdbeJumpHere(v, loopTop-1);
140882 sqlite3VdbeAddOp3(v, OP_VCheck, i, 3, isQuick);
140884 sqlite3VdbeAppendP4(v, pTab, P4_TABLEREF);
140885 a1 = sqlite3VdbeAddOp1(v, OP_IsNull, 3); VdbeCoverage(v);
140886 integrityCheckResultRow(v);
140887 sqlite3VdbeJumpHere(v, a1);
140905 aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
140913 sqlite3VdbeChangeP3(v, 0, sqlite3VdbeCurrentAddr(v)-2);
140963 returnSingleText(v, encnames[ENC(pParse->db)].zName);
141023 sqlite3VdbeUsesBtree(v, iDb);
141031 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setCookie));
141032 aOp = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
141052 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(readCookie));
141053 aOp = sqlite3VdbeAddOpList(v, ArraySize(readCookie),readCookie,0);
141058 sqlite3VdbeReusable(v);
141076 sqlite3VdbeLoadString(v, 1, zOpt);
141077 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
141079 sqlite3VdbeReusable(v);
141103 sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
141104 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
141120 returnSingleInt(v,
141296 sqlite3VdbeAddOp4Int(v, OP_IfSizeBetween, iTabCur,
141297 sqlite3VdbeCurrentAddr(v)+2+(opMask&1),
141300 VdbeCoverage(v);
141302 sqlite3VdbeAddOp2(v, OP_Rewind, iTabCur,
141303 sqlite3VdbeCurrentAddr(v)+2+(opMask&1));
141304 VdbeCoverage(v);
141310 sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC);
141311 sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1);
141313 sqlite3VdbeAddOp4(v, OP_SqlExec, nLimit ? 0x02 : 00, nLimit, 0,
141318 sqlite3VdbeAddOp0(v, OP_Expire);
141328 aOp = sqlite3VdbeGetOp(v, 0);
141329 iEnd = sqlite3VdbeCurrentAddr(v);
141351 returnSingleInt(v, db->busyTimeout);
141371 returnSingleInt(v, sqlite3_soft_heap_limit64(-1));
141392 returnSingleInt(v, sqlite3_hard_heap_limit64(-1));
141411 returnSingleInt(v, sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1));
141430 returnSingleInt(v, db->nAnalysisLimit); /* IMP: R-57594-65522 */
141456 sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zDbSName, zState);
141479 sqlite3VdbeVerifyNoResultRow(v);
143573 Vdbe *v = pParse->pVdbe;
143578 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
143595 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
143624 pSort->addrPush = sqlite3VdbeCurrentAddr(v);
143640 sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
143658 addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);
143660 addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
143662 VdbeCoverage(v);
143663 sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
143664 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
143669 sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
143674 addrJmp = sqlite3VdbeCurrentAddr(v);
143675 sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
143678 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
143679 sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
143681 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
143682 VdbeCoverage(v);
143684 sqlite3VdbeJumpHere(v, addrFirst);
143686 sqlite3VdbeJumpHere(v, addrJmp);
143705 sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
143706 VdbeCoverage(v);
143707 sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
143708 iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
143710 VdbeCoverage(v);
143711 sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
143721 sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
143724 sqlite3VdbeChangeP2(v, iSkip,
143725 pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
143728 pSort->addrPushEnd = sqlite3VdbeCurrentAddr(v)-1;
143736 Vdbe *v, /* Generate code into this VM */
143741 sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v);
143742 VdbeComment((v, "OFFSET"));
143799 Vdbe *v = pParse->pVdbe;
143811 iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
143815 sqlite3VdbeAddOp3(v, OP_Ne, regElem+i, iJump, regPrev+i);
143816 VdbeCoverage(v);
143818 sqlite3VdbeAddOp3(v, OP_Eq, regElem+i, addrRepeat, regPrev+i);
143819 VdbeCoverage(v);
143821 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
143822 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
143824 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
143825 sqlite3VdbeAddOp3(v, OP_Copy, regElem, regPrev, nResultCol-1);
143836 sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, regElem, nResultCol);
143837 VdbeCoverage(v);
143838 sqlite3VdbeAddOp3(v, OP_MakeRecord, regElem, nResultCol, r1);
143839 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, regElem, nResultCol);
143840 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
143882 Vdbe *v = pParse->pVdbe;
143883 sqlite3VdbeChangeToNoop(v, iOpenEphAddr);
143884 if( sqlite3VdbeGetOp(v, iOpenEphAddr+1)->opcode==OP_Explain ){
143885 sqlite3VdbeChangeToNoop(v, iOpenEphAddr+1);
143892 VdbeOp *pOp = sqlite3VdbeGetOp(v, iOpenEphAddr);
144005 Vdbe *v = pParse->pVdbe;
144022 assert( v );
144028 codeOffset(v, p->iOffset, iContinue);
144055 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
144056 VdbeComment((v, "%s", p->pEList->a[i].zEName));
144095 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
144156 codeOffset(v, p->iOffset, iContinue);
144168 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
144169 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
144179 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
144195 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);
144203 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
144213 int addr = sqlite3VdbeCurrentAddr(v) + 4;
144214 sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
144215 VdbeCoverage(v);
144216 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);
144225 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
144226 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
144227 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
144245 sqlite3VdbeAddOp2(v, OP_IsNull, regResult, iBreak); VdbeCoverage(v);
144247 sqlite3VdbeAddOp3(v, OP_MakeRecord,
144250 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult);
144252 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2);
144274 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
144276 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
144286 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
144317 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
144319 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
144347 addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
144349 VdbeCoverage(v);
144351 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
144353 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
144354 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
144357 sqlite3VdbeAddOp2(v, OP_SCopy,
144361 sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
144362 sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
144363 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
144364 if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
144391 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
144545 Vdbe *v = pParse->pVdbe; /* The prepared statement */
144577 sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd);
144578 sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush);
144583 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
144584 sqlite3VdbeGoto(v, addrBreak);
144585 sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
144601 sqlite3VdbeAddOp2(v, OP_Null, 0, pDest->iSdst);
144618 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
144620 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
144622 if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
144623 addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
144624 VdbeCoverage(v);
144626 sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
144629 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
144630 codeOffset(v, p->iOffset, addrContinue);
144634 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
144653 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
144655 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
144656 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
144657 sqlite3VdbeCurrentAddr(v)+1, regKey);
144663 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
144665 iJmp = sqlite3VdbeCurrentAddr(v);
144666 sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
144667 sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
144668 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
144687 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
144688 VdbeComment((v, "%s", aOutEx[i].zEName));
144691 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
144695 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow);
144696 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
144697 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
144698 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
144704 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
144706 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn);
144717 sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1);
144719 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow);
144721 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2);
144730 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
144732 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
144747 sqlite3VdbeResolveLabel(v, addrContinue);
144749 sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
144751 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
144753 sqlite3VdbeScanStatusRange(v, addrExplain, sqlite3VdbeCurrentAddr(v)-1, -1);
144754 if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
144755 sqlite3VdbeResolveLabel(v, addrBreak);
144937 Vdbe *v = pParse->pVdbe;
144956 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
144957 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
144958 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
144962 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
145002 Vdbe *v = pParse->pVdbe;
145017 assert( v!=0 );
145022 sqlite3VdbeSetNumCols(v, pEList->nExpr);
145033 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
145049 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
145051 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
145056 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
145366 Vdbe *v = 0;
145384 v = sqlite3GetVdbe(pParse);
145385 assert( v!=0 );
145387 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
145388 VdbeComment((v, "LIMIT counter"));
145390 sqlite3VdbeGoto(v, iBreak);
145397 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
145398 VdbeComment((v, "LIMIT counter"));
145399 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
145405 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
145406 VdbeComment((v, "OFFSET counter"));
145407 sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
145408 VdbeComment((v, "LIMIT+OFFSET"));
145521 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
145581 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
145584 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
145588 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
145590 VdbeComment((v, "Queue table"));
145592 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
145624 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
145627 sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
145629 sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
145631 sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
145633 sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
145637 codeOffset(v, regOffset, addrCont);
145641 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
145642 VdbeCoverage(v);
145644 sqlite3VdbeResolveLabel(v, addrCont);
145656 sqlite3VdbeGoto(v, addrTop);
145657 sqlite3VdbeResolveLabel(v, addrBreak);
145770 Vdbe *v; /* Generate code to this VDBE */
145787 v = sqlite3GetVdbe(pParse);
145788 assert( v!=0 ); /* The VDBE already created by calling function */
145794 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
145851 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
145852 VdbeComment((v, "Jump ahead if LIMIT reached"));
145854 sqlite3VdbeAddOp3(v, OP_OffsetLimit,
145872 sqlite3VdbeJumpHere(v, addr);
145900 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
145957 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
145958 iStart = sqlite3VdbeCurrentAddr(v);
145961 sqlite3VdbeResolveLabel(v, iCont);
145962 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
145963 sqlite3VdbeResolveLabel(v, iBreak);
145964 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
145984 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
146001 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
146029 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
146031 iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
146032 sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
146033 VdbeCoverage(v);
146037 sqlite3VdbeResolveLabel(v, iCont);
146038 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
146039 sqlite3VdbeResolveLabel(v, iBreak);
146040 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
146041 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
146094 sqlite3VdbeChangeP2(v, addr, nCol);
146095 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
146157 Vdbe *v = pParse->pVdbe;
146161 addr = sqlite3VdbeCurrentAddr(v);
146168 addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
146169 addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
146171 sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v);
146172 sqlite3VdbeJumpHere(v, addr1);
146173 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
146174 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
146180 codeOffset(v, p->iOffset, iContinue);
146190 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
146191 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
146192 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
146193 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
146206 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
146208 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
146236 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
146250 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
146258 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
146263 sqlite3VdbeResolveLabel(v, iContinue);
146264 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
146364 Vdbe *v; /* Generate code to this VDBE */
146400 v = pParse->pVdbe;
146401 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
146470 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
146513 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
146515 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
146534 addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
146535 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
146536 VdbeComment((v, "left SELECT"));
146540 sqlite3VdbeEndCoroutine(v, regAddrA);
146541 sqlite3VdbeJumpHere(v, addr1);
146546 addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
146547 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
146548 VdbeComment((v, "right SELECT"));
146557 sqlite3VdbeEndCoroutine(v, regAddrB);
146562 VdbeNoopComment((v, "Output routine for A"));
146571 VdbeNoopComment((v, "Output routine for B"));
146584 VdbeNoopComment((v, "eof-A subroutine"));
146585 addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
146586 addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
146587 VdbeCoverage(v);
146588 sqlite3VdbeGoto(v, addrEofA);
146599 VdbeNoopComment((v, "eof-B subroutine"));
146600 addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
146601 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
146602 sqlite3VdbeGoto(v, addrEofB);
146607 VdbeNoopComment((v, "A-lt-B subroutine"));
146608 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
146609 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
146610 sqlite3VdbeGoto(v, labelCmpr);
146620 VdbeNoopComment((v, "A-eq-B subroutine"));
146622 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
146623 sqlite3VdbeGoto(v, labelCmpr);
146628 VdbeNoopComment((v, "A-gt-B subroutine"));
146629 addrAgtB = sqlite3VdbeCurrentAddr(v);
146631 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
146633 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
146634 sqlite3VdbeGoto(v, labelCmpr);
146638 sqlite3VdbeJumpHere(v, addr1);
146639 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
146640 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
146644 sqlite3VdbeResolveLabel(v, labelCmpr);
146645 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
146646 sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
146648 sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
146649 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
146653 sqlite3VdbeResolveLabel(v, labelEnd);
149558 Vdbe *v = pParse->pVdbe;
149567 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->iFirstReg,
149579 pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
149609 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
149623 Vdbe *v = pParse->pVdbe;
149654 iTop = sqlite3VdbeAddOp1(v, OP_Rewind, pF->iOBTab); VdbeCoverage(v);
149656 sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, nKey+j, regAgg+j);
149662 sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, iBaseCol+j, regSubtype);
149663 sqlite3VdbeAddOp2(v, OP_SetSubtype, regSubtype, regAgg+j);
149667 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i));
149668 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
149669 sqlite3VdbeChangeP5(v, (u8)nArg);
149670 sqlite3VdbeAddOp2(v, OP_Next, pF->iOBTab, iTop+1); VdbeCoverage(v);
149671 sqlite3VdbeJumpHere(v, iTop);
149674 sqlite3VdbeAddOp2(v, OP_AggFinal, AggInfoFuncReg(pAggInfo,i),
149676 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
149702 Vdbe *v = pParse->pVdbe;
149740 sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit);
149775 sqlite3VdbeAddOp2(v, OP_Sequence, pF->iOBTab, regAgg+jj);
149787 sqlite3VdbeAddOp2(v, OP_GetSubtype, regBase+kk, regAgg+jj);
149808 sqlite3VdbeAddOp3(v, OP_MakeRecord, regAgg, regAggSz-1,
149810 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pF->iOBTab, regAgg+regAggSz-1,
149827 sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0,
149830 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i));
149831 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
149832 sqlite3VdbeChangeP5(v, (u8)nArg);
149836 sqlite3VdbeResolveLabel(v, addrNext);
149843 addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
149851 sqlite3VdbeJumpHereOrPopInst(v, addrHitTest);
150197 Vdbe *v; /* The virtual machine under construction */
150215 v = sqlite3GetVdbe(pParse);
150626 int addrTop = sqlite3VdbeCurrentAddr(v)+1;
150629 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pItem->regReturn, 0, addrTop);
150630 VdbeComment((v, "%!S", pItem));
150638 sqlite3VdbeEndCoroutine(v, pItem->regReturn);
150639 sqlite3VdbeJumpHere(v, addrTop-1);
150647 sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e);
150649 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur);
150650 VdbeComment((v, "%!S", pItem));
150657 sqlite3VdbeAddOp2(v, OP_Gosub, pPrior->regReturn, pPrior->addrFillSub);
150659 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
150672 topAddr = sqlite3VdbeAddOp0(v, OP_Goto);
150679 onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
150680 VdbeComment((v, "materialize %!S", pItem));
150682 VdbeNoopComment((v, "materialize %!S", pItem));
150689 if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
150690 sqlite3VdbeAddOp2(v, OP_Return, pItem->regReturn, topAddr+1);
150691 VdbeComment((v, "end %!S", pItem));
150692 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
150693 sqlite3VdbeJumpHere(v, topAddr);
150776 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
150787 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
150810 sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen);
150818 sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
150822 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
150866 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
150879 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
150880 sqlite3VdbeResolveLabel(v, addrGosub);
150881 VdbeNoopComment((v, "inner-loop subroutine"));
150884 sqlite3VdbeResolveLabel(v, iCont);
150885 sqlite3VdbeAddOp1(v, OP_Return, regGosub);
150886 VdbeComment((v, "end inner-loop subroutine"));
150887 sqlite3VdbeResolveLabel(v, iBreak);
151059 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
151075 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
151076 VdbeComment((v, "clear abort flag"));
151077 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
151084 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
151148 sqlite3VdbeScanStatusCounters(v, addrExp, 0, sqlite3VdbeCurrentAddr(v));
151149 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
151150 sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
151151 sqlite3VdbeScanStatusRange(v, addrExp, sqlite3VdbeCurrentAddr(v)-2, -1);
151158 sqlite3VdbeScanStatusCounters(v, addrExp, sqlite3VdbeCurrentAddr(v), 0);
151159 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
151160 sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
151161 VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
151163 sqlite3VdbeScanStatusRange(v, addrExp, -1, sortPTab);
151164 sqlite3VdbeScanStatusRange(v, addrExp, -1, pAggInfo->sortingIdx);
151195 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
151203 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
151205 sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx,
151210 sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
151216 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
151218 addr1 = sqlite3VdbeCurrentAddr(v);
151219 sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v);
151231 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
151232 VdbeComment((v, "output one row"));
151233 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
151234 VdbeComment((v, "check abort flag"));
151235 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
151236 VdbeComment((v, "reset accumulator"));
151241 sqlite3VdbeJumpHere(v, addr1);
151243 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
151244 VdbeComment((v, "indicate data in accumulator"));
151249 sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);
151250 VdbeCoverage(v);
151254 sqlite3VdbeChangeToNoop(v, addrSortingIdx);
151260 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
151261 VdbeComment((v, "output final row"));
151265 sqlite3VdbeGoto(v, addrEnd);
151274 addrSetAbort = sqlite3VdbeCurrentAddr(v);
151275 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
151276 VdbeComment((v, "set abort flag"));
151277 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
151278 sqlite3VdbeResolveLabel(v, addrOutputRow);
151279 addrOutputRow = sqlite3VdbeCurrentAddr(v);
151280 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
151281 VdbeCoverage(v);
151282 VdbeComment((v, "Groupby result generator entry point"));
151283 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
151289 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
151290 VdbeComment((v, "end groupby result generator"));
151294 sqlite3VdbeResolveLabel(v, addrReset);
151296 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
151297 VdbeComment((v, "indicate accumulator empty"));
151298 sqlite3VdbeAddOp1(v, OP_Return, regReset);
151358 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
151360 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
151363 sqlite3VdbeAddOp2(v, OP_Count, iCsr, AggInfoFuncReg(pAggInfo,0));
151364 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
151392 sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
151432 if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
151434 sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);
151446 sqlite3VdbeResolveLabel(v, addrEnd);
151464 sqlite3VdbeResolveLabel(v, iEnd);
152068 Vdbe *v;
152089 v = sqlite3GetVdbe(pParse);
152090 if( v==0 ) goto triggerfinish_cleanup;
152101 sqlite3VdbeAddParseSchemaOp(v, iDb,
152385 Vdbe *v;
152408 if( (v = sqlite3GetVdbe(pParse))!=0 ){
152414 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
152743 Vdbe *v = pParse->pVdbe;
152750 assert( v!=0 );
152803 sqlite3VdbeAddOp1(v, OP_RealAffinity, reg+i);
152806 sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i);
152807 sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
152808 sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
152828 Vdbe *v = pParse->pVdbe;
152833 assert( v!=0 );
152853 sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0,
152867 sqlite3VdbeAddOp0(v, OP_ResetCount);
152878 sqlite3VdbeAddOp0(v, OP_ResetCount);
152886 sqlite3VdbeAddOp0(v, OP_ResetCount);
152952 Vdbe *v; /* Temporary VM */
152988 v = sqlite3GetVdbe(&sSubParse);
152989 if( v ){
152990 VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",
153000 sqlite3VdbeChangeP4(v, -1,
153025 sqlite3VdbeResolveLabel(v, iEndTrigger);
153027 sqlite3VdbeAddOp0(v, OP_Halt);
153028 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
153033 pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
153040 sqlite3VdbeDelete(v);
153099 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
153109 sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
153112 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
153119 sqlite3VdbeChangeP5(v, (u8)bRecursive);
153334 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
153341 u8 enc = ENC(sqlite3VdbeDb(v));
153343 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
153345 sqlite3ValueFromExpr(sqlite3VdbeDb(v),
153349 sqlite3VdbeAppendP4(v, pValue, P4_MEM);
153354 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
153572 Vdbe *v; /* The virtual database engine */
153730 v = sqlite3GetVdbe(pParse);
153731 if( v==0 ) goto update_cleanup;
153876 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
153946 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
153950 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
153952 addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet);
153963 if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
153964 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol);
153969 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
154052 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
154055 sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid);
154057 if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen);
154067 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
154071 if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen);
154075 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
154077 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
154099 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
154104 sqlite3VdbeJumpHereOrPopInst(v, addrOnce);
154117 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
154118 VdbeCoverage(v);
154123 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
154124 VdbeCoverageIf(v, pPk==0);
154125 VdbeCoverageIf(v, pPk!=0);
154128 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
154129 addrTop = sqlite3VdbeCurrentAddr(v);
154134 sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i);
154137 v, OP_NotFound, iDataCur, labelContinue, iPk, nPk
154138 ); VdbeCoverage(v);
154140 sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
154142 v, OP_NotExists, iDataCur, labelContinue, regOldRowid
154143 ); VdbeCoverage(v);
154147 sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
154148 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0);
154149 VdbeCoverage(v);
154152 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
154154 addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
154155 VdbeCoverage(v);
154156 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
154157 VdbeCoverage(v);
154171 sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid);
154173 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
154191 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
154193 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
154198 if( isView ) sqlite3VdbeAddOp2(v, OP_Null, 0, regOldRowid);
154200 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
154222 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
154231 sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k);
154243 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
154246 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
154262 sqlite3TableAffinity(v, pTab, regNew);
154274 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
154275 VdbeCoverage(v);
154277 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
154278 VdbeCoverage(v);
154294 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
154319 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
154321 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
154323 VdbeCoverage(v);
154340 sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur);
154354 sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
154360 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
154363 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
154367 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
154393 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
154407 sqlite3VdbeResolveLabel(v, labelContinue);
154410 sqlite3VdbeResolveLabel(v, labelContinue);
154411 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
154413 sqlite3VdbeResolveLabel(v, labelBreak);
154428 sqlite3CodeChangeCount(v, regRowCount, "rows updated");
154485 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
154503 assert( v );
154505 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
154563 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
154564 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */
154568 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
154572 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
154581 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg);
154582 sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1);
154593 sqlite3VdbeChangeToNoop(v, addr);
154594 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
154599 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
154603 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
154605 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
154606 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
154618 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
154623 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
154627 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
154628 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
154634 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
154635 sqlite3VdbeJumpHere(v, addr);
154636 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
154918 Vdbe *v = pParse->pVdbe;
154925 assert( v!=0 );
154929 VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
154933 sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid);
154934 sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid);
154935 VdbeCoverage(v);
154946 sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i);
154947 VdbeComment((v, "%s.%s", pIdx->zName,
154950 sqlite3VdbeVerifyAbortable(v, OE_Abort);
154951 i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk);
154952 VdbeCoverage(v);
154953 sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0,
154956 sqlite3VdbeJumpHere(v, i);
154965 sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i);
154970 VdbeNoopComment((v, "End DO UPDATE of UPSERT"));
155082 Vdbe *v = sqlite3GetVdbe(pParse);
155084 if( v==0 ) goto build_vacuum_end;
155108 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
155109 sqlite3VdbeUsesBtree(v, iDb);
155860 Vdbe *v;
155889 v = sqlite3GetVdbe(pParse);
155892 sqlite3VdbeAddOp0(v, OP_Expire);
155894 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
155898 sqlite3VdbeLoadString(v, iReg, pTab->zName);
155899 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
156122 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
157322 # define sqlite3WhereExplainOneScan(u,v,w,x) 0
157323 # define sqlite3WhereExplainBloomFilter(u,v,w) 0
157327 Vdbe *v, /* Vdbe to add scanstatus entry to */
157337 Vdbe *v, /* Prepared statement under construction */
157544 Vdbe *v = pParse->pVdbe; /* VM being constructed */
157631 ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),
157654 Vdbe *v = pParse->pVdbe; /* VM being constructed */
157682 ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),
157685 sqlite3VdbeScanStatus(v, sqlite3VdbeCurrentAddr(v)-1, 0, 0, 0, 0);
157701 Vdbe *v, /* Vdbe to add scanstatus entry to */
157706 if( IS_STMT_SCANSTATUS( sqlite3VdbeDb(v) ) ){
157719 v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj
157724 sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iTabCur);
157727 sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur);
157731 VdbeOp *pOp = sqlite3VdbeGetOp(v, addr-1);
157732 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->opcode==OP_InitCoroutine );
157733 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->p2>addr );
157734 sqlite3VdbeScanStatusRange(v, addrExplain, addr, pOp->p2-1);
157822 Vdbe *v = pParse->pVdbe;
157827 assert( v!=0 );
157844 sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
157891 ** SELECT * FROM t1 WHERE (a,b,c,d,e) IN (SELECT v,w,x,y,z FROM t2)
158009 Vdbe *v = pParse->pVdbe;
158018 sqlite3VdbeAddOp2(v, OP_Null, 0, iReg);
158077 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
158078 VdbeCoverageIf(v, bRev);
158079 VdbeCoverageIf(v, !bRev);
158104 pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut);
158107 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
158109 sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v);
158131 sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq);
158212 Vdbe *v = pParse->pVdbe; /* The vm under construction */
158240 sqlite3VdbeAddOp3(v, OP_Null, 0, regBase, regBase+nSkip-1);
158241 sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur);
158242 VdbeCoverageIf(v, bRev==0);
158243 VdbeCoverageIf(v, bRev!=0);
158244 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
158245 j = sqlite3VdbeAddOp0(v, OP_Goto);
158247 pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT),
158249 VdbeCoverageIf(v, bRev==0);
158250 VdbeCoverageIf(v, bRev!=0);
158251 sqlite3VdbeJumpHere(v, j);
158253 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, j, regBase+j);
158255 VdbeComment((v, "%s", explainIndexColumnName(pIdx, j)));
158276 sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j);
158290 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
158291 VdbeCoverage(v);
158327 Vdbe *v, /* prepared statement under construction */
158334 pOp = sqlite3VdbeGetLastOp(v);
158465 Vdbe *v = pParse->pVdbe;
158552 sqlite3VdbeAddOp4(v, OP_CursorHint,
158594 Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */
158600 sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
158617 sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY);
158636 Vdbe *v = pParse->pVdbe;
158640 sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
158778 Vdbe *v, /* Prepared statement under construction */
158808 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName));
158849 sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
158850 VdbeComment((v, "init LEFT JOIN match flag"));
158864 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub);
158865 pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
158866 VdbeCoverage(v);
158867 VdbeComment((v, "next row of %s", pTabItem->pTab->zName));
158891 sqlite3VdbeAddOp3(v, OP_VInitIn, iTab, iTarget, iCache);
158905 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWInfo->pSelect->iOffset);
158906 VdbeComment((v,"Zero OFFSET counter"));
158910 sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
158911 sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1);
158912 sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg,
158915 VdbeCoverage(v);
158922 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
158946 pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop);
158951 sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3);
159013 sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt);
159014 VdbeCoverage(v);
159015 sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt,
159017 VdbeCoverage(v);
159020 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg);
159021 VdbeCoverage(v);
159084 sqlite3VdbeAddOp3(v, op, iCur, addrBrk, r1);
159085 VdbeComment((v, "pk"));
159086 VdbeCoverageIf(v, pX->op==TK_GT);
159087 VdbeCoverageIf(v, pX->op==TK_LE);
159088 VdbeCoverageIf(v, pX->op==TK_LT);
159089 VdbeCoverageIf(v, pX->op==TK_GE);
159092 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt);
159093 VdbeCoverageIf(v, bRev==0);
159094 VdbeCoverageIf(v, bRev!=0);
159116 start = sqlite3VdbeCurrentAddr(v);
159123 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
159124 sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg);
159125 VdbeCoverageIf(v, testOp==OP_Le);
159126 VdbeCoverageIf(v, testOp==OP_Lt);
159127 VdbeCoverageIf(v, testOp==OP_Ge);
159128 VdbeCoverageIf(v, testOp==OP_Gt);
159129 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL);
159223 sqlite3VdbeAddOp2(v, OP_Integer, 1, (int)pLevel->iLikeRepCntr);
159224 VdbeComment((v, "LIKE loop counter"));
159225 pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v);
159261 sqlite3VdbeAddOp2(v, OP_Integer, 0, regBignull);
159279 sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur);
159307 whereLikeOptimizationStringFixup(v, pLevel, pRangeStart);
159311 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
159312 VdbeCoverage(v);
159327 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
159331 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
159342 sqlite3VdbeAddOp2(v, OP_Integer, 1, regBignull);
159343 VdbeComment((v, "NULL-scan pass ctr"));
159346 sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt,
159348 VdbeCoverage(v);
159364 addrSeekScan = sqlite3VdbeAddOp1(v, OP_SeekScan,
159367 sqlite3VdbeChangeP5(v, 1);
159368 sqlite3VdbeChangeP2(v, addrSeekScan, sqlite3VdbeCurrentAddr(v)+1);
159371 VdbeCoverage(v);
159373 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
159374 VdbeCoverage(v);
159375 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
159376 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
159377 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT );
159378 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
159379 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
159380 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT );
159387 sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2);
159389 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase,
159391 VdbeCoverage(v);
159392 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
159393 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
159394 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
159395 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
159409 whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd);
159413 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
159414 VdbeCoverage(v);
159432 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
159441 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
159447 sqlite3VdbeAddOp2(v, OP_IfNot, regBignull, sqlite3VdbeCurrentAddr(v)+3);
159448 VdbeComment((v, "If NULL-scan 2nd pass"));
159449 VdbeCoverage(v);
159452 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
159453 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
159454 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
159455 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
159456 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
159457 if( addrSeekScan ) sqlite3VdbeJumpHere(v, addrSeekScan);
159465 sqlite3VdbeAddOp2(v, OP_If, regBignull, sqlite3VdbeCurrentAddr(v)+2);
159466 VdbeComment((v, "If NULL-scan 1st pass"));
159467 VdbeCoverage(v);
159469 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase,
159471 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
159472 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
159473 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
159474 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
159478 sqlite3VdbeAddOp3(v, OP_SeekHit, iIdxCur, nEq, nEq);
159493 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j);
159495 sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont,
159496 iRowidReg, pPk->nKeyCol); VdbeCoverage(v);
159643 sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset);
159647 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol);
159652 iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn);
159743 sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain);
159753 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
159754 jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0,
159756 VdbeCoverage(v);
159767 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
159782 jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk);
159783 VdbeCoverage(v);
159786 sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid);
159787 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, regRowset, regRowid,
159789 if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
159798 sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody);
159802 if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1);
159855 sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v));
159856 sqlite3VdbeGoto(v, pLevel->addrBrk);
159857 sqlite3VdbeResolveLabel(v, iLoopBody);
159865 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
159887 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
159888 VdbeCoverageIf(v, bRev==0);
159889 VdbeCoverageIf(v, bRev!=0);
159895 pLevel->addrVisit = sqlite3VdbeCurrentAddr(v);
159971 skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1));
159972 VdbeCoverageIf(v, (x&1)==1);
159973 VdbeCoverageIf(v, (x&1)==0);
159979 VdbeNoopComment((v, "WhereTerm[%d] (%p) priority=%d",
159988 if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr);
160033 VdbeModuleComment((v, "begin transitive constraint"));
160058 sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
160067 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
160070 jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, 0, r+1, nPk);
160071 VdbeCoverage(v);
160072 VdbeComment((v, "match against %s", pTab->zName));
160073 sqlite3VdbeAddOp3(v, OP_MakeRecord, r+1, nPk, r);
160074 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pRJ->iMatch, r, r+1, nPk);
160075 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pRJ->regBloom, 0, r+1, nPk);
160076 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
160077 sqlite3VdbeJumpHere(v, jmp1);
160085 pLevel->addrFirst = sqlite3VdbeCurrentAddr(v);
160086 sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
160087 VdbeComment((v, "record LEFT JOIN hit"));
160101 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pRJ->regReturn);
160102 pRJ->addrSubrtn = sqlite3VdbeCurrentAddr(v);
160151 Vdbe *v = pParse->pVdbe;
160163 sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn,
160173 v, OP_Null, 0, pRight->regResult,
160177 sqlite3VdbeAddOp1(v, OP_NullRow, pWInfo->a[k].iTabCur);
160180 sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur);
160214 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
160223 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
160226 jmp = sqlite3VdbeAddOp4Int(v, OP_Filter, pRJ->regBloom, 0, r, nPk);
160227 VdbeCoverage(v);
160228 sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, addrCont, r, nPk);
160229 VdbeCoverage(v);
160230 sqlite3VdbeJumpHere(v, jmp);
160231 sqlite3VdbeAddOp2(v, OP_Gosub, pRJ->regReturn, pRJ->addrSubrtn);
160537 Vdbe *v = pParse->pVdbe;
160538 sqlite3VdbeSetVarmask(v, pRight->iColumn);
160549 sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0);
162236 SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe *v, WhereInfo *pWInfo){
162244 sqlite3VdbeGoto(v, pInner->addrNxt);
162248 sqlite3VdbeGoto(v, pWInfo->iBreak);
162835 Vdbe *v = pParse->pVdbe;
162836 VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
162837 int iEnd = sqlite3VdbeCurrentAddr(v);
163060 Vdbe *v; /* Prepared statement under construction */
163087 v = pParse->pVdbe;
163088 assert( v!=0 );
163089 addrInit = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
163226 sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1);
163228 VdbeComment((v, "for %s", pTable->zName));
163232 sqlite3VdbeAddOp2(v, OP_Blob, 10000, pLevel->regFilter);
163239 addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0);
163240 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSrc->addrFillSub);
163241 addrTop = sqlite3VdbeAddOp1(v, OP_Yield, regYield);
163242 VdbeCoverage(v);
163243 VdbeComment((v, "next row of %s", pSrc->pTab->zName));
163245 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
163257 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0,
163260 sqlite3VdbeScanStatusCounters(v, addrExp, addrExp, sqlite3VdbeCurrentAddr(v));
163261 sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
163262 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
163263 if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue);
163265 sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
163270 sqlite3VdbeGoto(v, addrTop);
163273 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v);
163274 sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX);
163276 sqlite3VdbeJumpHere(v, addrTop);
163280 sqlite3VdbeJumpHere(v, addrInit);
163281 sqlite3VdbeScanStatusRange(v, addrExp, addrExp, -1);
163320 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
163332 assert( v!=0 );
163336 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
163368 sqlite3VdbeAddOp2(v, OP_Blob, (int)sz, pLevel->regFilter);
163370 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
163382 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, r1);
163383 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, 1);
163394 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, n);
163397 sqlite3VdbeResolveLabel(v, addrCont);
163398 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1);
163399 VdbeCoverage(v);
163400 sqlite3VdbeJumpHere(v, addrTop);
163422 sqlite3VdbeJumpHere(v, addrOnce);
164367 if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V';
165260 /* TUNING v----- 10 to bias toward indexed IN */
168358 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
168775 sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB);
168804 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32);
168809 sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ|bFordelete);
168813 sqlite3VdbeChangeP5(v, bFordelete);
168816 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0,
168864 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
168873 sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ);
168875 VdbeComment((v, "%s", pIx->zName));
168887 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, iIndexCur, 0, 0,
168900 sqlite3VdbeAddOp2(v, OP_Blob, 65536, pRJ->regBloom);
168902 sqlite3VdbeAddOp2(v, OP_Null, 0, pRJ->regReturn);
168906 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, 1);
168911 sqlite3VdbeAppendP4(v, pInfo, P4_KEYINFO);
168915 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, pPk->nKeyCol);
168926 pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
168943 sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub);
168945 int iOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
168946 sqlite3VdbeAddOp2(v, OP_Gosub, pSrc->regReturn, pSrc->addrFillSub);
168947 sqlite3VdbeJumpHere(v, iOnce);
168964 pLevel->addrBody = sqlite3VdbeCurrentAddr(v);
168965 notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady);
168968 sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain);
168973 VdbeModuleComment((v, "Begin WHERE-core"));
168974 pWInfo->iEndWhere = sqlite3VdbeCurrentAddr(v);
169017 Vdbe *v = pParse->pVdbe;
169023 int iEnd = sqlite3VdbeCurrentAddr(v);
169028 VdbeModuleComment((v, "End WHERE-core"));
169036 sqlite3VdbeResolveLabel(v, pLevel->addrCont);
169038 pRJ->endSubrtn = sqlite3VdbeCurrentAddr(v);
169039 sqlite3VdbeAddOp3(v, OP_Return, pRJ->regReturn, pRJ->addrSubrtn, 1);
169040 VdbeCoverage(v);
169059 sqlite3VdbeAddOp3(v, OP_Column, pLevel->iIdxCur, j, r1+j);
169063 addrSeek = sqlite3VdbeAddOp4Int(v, op, pLevel->iIdxCur, 0, r1, n);
169064 VdbeCoverageIf(v, op==OP_SeekLT);
169065 VdbeCoverageIf(v, op==OP_SeekGT);
169066 sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2);
169070 if( pLevel->addrCont ) sqlite3VdbeResolveLabel(v, pLevel->addrCont);
169071 sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
169072 sqlite3VdbeChangeP5(v, pLevel->p5);
169073 VdbeCoverage(v);
169074 VdbeCoverageIf(v, pLevel->op==OP_Next);
169075 VdbeCoverageIf(v, pLevel->op==OP_Prev);
169076 VdbeCoverageIf(v, pLevel->op==OP_VNext);
169078 sqlite3VdbeResolveLabel(v, pLevel->addrBignull);
169079 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1);
169080 VdbeCoverage(v);
169083 if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek);
169086 sqlite3VdbeResolveLabel(v, pLevel->addrCont);
169091 sqlite3VdbeResolveLabel(v, pLevel->addrNxt);
169093 assert( sqlite3VdbeGetOp(v, pIn->addrInTop+1)->opcode==OP_IsNull
169095 sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
169110 sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur,
169111 sqlite3VdbeCurrentAddr(v) + 2 + bEarlyOut);
169112 VdbeCoverage(v);
169115 sqlite3VdbeAddOp4Int(v, OP_IfNoHope, pLevel->iIdxCur,
169116 sqlite3VdbeCurrentAddr(v)+2,
169118 VdbeCoverage(v);
169123 sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
169126 sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
169127 VdbeCoverage(v);
169128 VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev);
169129 VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next);
169131 sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
169134 sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
169136 sqlite3VdbeAddOp3(v, OP_Return, pLevel->pRJ->regReturn, 0, 1);
169137 VdbeCoverage(v);
169140 sqlite3VdbeGoto(v, pLevel->addrSkip);
169141 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
169142 sqlite3VdbeJumpHere(v, pLevel->addrSkip);
169143 sqlite3VdbeJumpHere(v, pLevel->addrSkip-2);
169147 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, (int)(pLevel->iLikeRepCntr>>1),
169149 VdbeCoverage(v);
169154 addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
169164 sqlite3VdbeAddOp3(v, OP_Null, 0, n, n+m-1);
169166 sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur);
169174 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
169177 sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
169180 sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst);
169182 sqlite3VdbeGoto(v, pLevel->addrFirst);
169184 sqlite3VdbeJumpHere(v, addr);
169186 VdbeModuleComment((v, "End WHERE-loop%d: %s", i,
169269 pOp = sqlite3VdbeGetOp(v, k - 1);
169274 pOp = sqlite3VdbeGetOp(v, k);
169336 sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
170312 Vdbe *v = sqlite3GetVdbe(pParse);
170402 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
170742 Vdbe *v = sqlite3GetVdbe(pParse);
170744 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr);
170745 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr);
170746 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr);
170747 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr);
170755 sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1);
170759 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne);
170765 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
170766 sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
170767 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr);
170793 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2);
170794 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
170795 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
170803 sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
170807 sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
170834 Vdbe *v = sqlite3GetVdbe(pParse);
170837 sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
170840 sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
170841 sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg);
170842 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL);
170843 VdbeCoverage(v);
170845 VdbeCoverageIf(v, eCond==3);
170846 VdbeCoverageIf(v, eCond==4);
170848 sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2);
170849 VdbeCoverage(v);
170851 VdbeCoverageIf(v, eCond==0);
170852 VdbeCoverageIf(v, eCond==1);
170853 VdbeCoverageIf(v, eCond==2);
170855 sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
170856 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC);
170857 VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */
170858 VdbeCoverageNeverNullIf(v, eCond==1); /* the OP_MustBeInt */
170859 VdbeCoverageNeverNullIf(v, eCond==2);
170860 VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */
170861 VdbeCoverageNeverNullIf(v, eCond==4); /* the OP_Ge */
170863 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort);
170864 sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC);
170972 Vdbe *v = sqlite3GetVdbe(p->pParse);
170977 sqlite3VdbeAddOp3(v, OP_Column, csr, iColOff+i, reg+i);
171009 Vdbe *v = sqlite3GetVdbe(pParse);
171025 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i);
171027 sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i);
171036 int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg);
171037 VdbeCoverage(v);
171039 sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1);
171040 sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp);
171041 sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2);
171042 sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2);
171044 sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1);
171045 VdbeCoverageNeverTaken(v);
171046 sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp);
171047 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
171049 sqlite3VdbeJumpHere(v, addrIsNull);
171055 sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1);
171064 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp);
171065 addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1);
171066 VdbeCoverage(v);
171071 int iOp = sqlite3VdbeCurrentAddr(v);
171079 for(iEnd=sqlite3VdbeCurrentAddr(v); iOp<iEnd; iOp++){
171080 VdbeOp *pOp = sqlite3VdbeGetOp(v, iOp);
171091 sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ);
171093 sqlite3VdbeAddOp3(v, bInverse? OP_AggInverse : OP_AggStep,
171095 sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF);
171096 sqlite3VdbeChangeP5(v, (u8)nArg);
171100 if( addrIf ) sqlite3VdbeJumpHere(v, addrIf);
171121 Vdbe *v = sqlite3GetVdbe(pParse);
171129 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
171130 sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp);
171131 VdbeCoverage(v);
171132 sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult);
171133 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
171139 sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg);
171140 sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF);
171141 sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult);
171142 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
171144 sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult);
171145 sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF);
171161 Vdbe *v = p->pVdbe;
171174 VdbeModuleComment((v, "windowFullScan begin"));
171190 sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid);
171194 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
171197 sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid);
171198 VdbeCoverage(v);
171199 addrNext = sqlite3VdbeCurrentAddr(v);
171200 sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid);
171201 sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid);
171202 VdbeCoverageNeverNull(v);
171205 sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid);
171206 VdbeCoverageNeverNull(v);
171216 addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid);
171217 VdbeCoverageNeverNull(v);
171221 sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer);
171222 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
171223 addr = sqlite3VdbeCurrentAddr(v)+1;
171224 sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr);
171225 VdbeCoverageEqNe(v);
171227 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext);
171229 if( addrEq ) sqlite3VdbeJumpHere(v, addrEq);
171234 sqlite3VdbeResolveLabel(v, lblNext);
171235 sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext);
171236 VdbeCoverage(v);
171237 sqlite3VdbeJumpHere(v, addrNext-1);
171238 sqlite3VdbeJumpHere(v, addrNext+1);
171247 VdbeModuleComment((v, "windowFullScan end"));
171265 Vdbe *v = p->pVdbe;
171282 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
171285 sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg);
171288 sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg);
171290 sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg);
171291 sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg);
171292 VdbeCoverageNeverNull(v);
171293 sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg);
171294 VdbeCoverageNeverTaken(v);
171295 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
171296 sqlite3VdbeResolveLabel(v, lbl);
171307 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
171309 sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult);
171311 sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg);
171314 sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val);
171318 sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2);
171319 sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg);
171323 sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg);
171324 VdbeCoverage(v);
171325 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
171326 sqlite3VdbeResolveLabel(v, lbl);
171331 sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub);
171341 Vdbe *v = sqlite3GetVdbe(pParse);
171348 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
171352 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
171353 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
171358 sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
171359 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
171405 Vdbe *v = sqlite3GetVdbe(pParse);
171409 sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal);
171410 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
171411 sqlite3VdbeAddOp3(v, OP_Jump,
171412 sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1
171414 VdbeCoverageEqNe(v);
171415 sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1);
171417 sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
171453 Vdbe *v = sqlite3GetVdbe(pParse);
171478 VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl",
171504 int addr = sqlite3VdbeAddOp1(v, OP_NotNull, reg1); VdbeCoverage(v);
171507 sqlite3VdbeAddOp2(v, OP_Goto, 0, lbl);
171510 sqlite3VdbeAddOp2(v, OP_NotNull, reg2, lbl);
171511 VdbeCoverage(v);
171514 sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl);
171515 VdbeCoverage(v);
171519 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
171522 sqlite3VdbeJumpHere(v, addr);
171523 sqlite3VdbeAddOp2(v, OP_IsNull, reg2,
171525 VdbeCoverage(v);
171541 sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
171542 addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1);
171543 VdbeCoverage(v);
171545 sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
171547 sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1);
171548 sqlite3VdbeJumpHere(v, addrGe);
171553 sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
171555 sqlite3VdbeAppendP4(v, (void*)pColl, P4_COLLSEQ);
171556 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
171557 sqlite3VdbeResolveLabel(v, addrDone);
171560 testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge);
171561 testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt);
171562 testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le);
171563 testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt);
171567 VdbeModuleComment((v, "CodeRangeTest: end"));
171586 Vdbe *v = p->pVdbe;
171602 addrNextRange = sqlite3VdbeCurrentAddr(v);
171620 sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, lblDone, 1);
171621 VdbeCoverage(v);
171628 addrContinue = sqlite3VdbeCurrentAddr(v);
171642 sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
171643 sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2);
171644 sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1);
171645 VdbeCoverage(v);
171647 sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid1);
171648 sqlite3VdbeAddOp3(v, OP_Ge, p->regRowid, lblDone, regRowid1);
171649 VdbeCoverageNeverNull(v);
171668 sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1);
171680 sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1);
171688 sqlite3VdbeAddOp1(v, OP_Delete, csr);
171689 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
171693 sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2);
171694 VdbeCoverage(v);
171695 ret = sqlite3VdbeAddOp0(v, OP_Goto);
171697 sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer);
171698 VdbeCoverage(v);
171700 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblDone);
171713 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNextRange);
171715 sqlite3VdbeResolveLabel(v, lblDone);
172136 Vdbe *v = sqlite3GetVdbe(pParse);
172172 s.pVdbe = v;
172247 sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput);
172249 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord);
172264 addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart);
172265 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
172266 sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2);
172267 VdbeCoverageEqNe(v);
172268 addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart);
172269 VdbeComment((v, "call flush_partition"));
172270 sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1);
172274 sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, s.regRowid);
172275 sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, s.regRowid);
172276 addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, s.regRowid);
172277 VdbeCoverageNeverNull(v);
172293 int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd);
172294 VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */
172295 VdbeCoverageNeverNullIf(v, op==OP_Le); /* values previously checked */
172297 sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);
172299 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
172300 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
172301 sqlite3VdbeJumpHere(v, addrGe);
172305 sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart);
172309 sqlite3VdbeAddOp1(v, OP_Rewind, s.start.csr);
172311 sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);
172312 sqlite3VdbeAddOp1(v, OP_Rewind, s.end.csr);
172314 sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1);
172315 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);
172316 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
172317 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1);
172320 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
172322 sqlite3VdbeJumpHere(v, addrNe);
172333 int addrNext = sqlite3VdbeCurrentAddr(v);
172337 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext);
172338 sqlite3VdbeResolveLabel(v, lbl);
172357 addr = sqlite3VdbeCurrentAddr(v);
172365 sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
172366 sqlite3VdbeResolveLabel(v, lbl);
172370 addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
172371 VdbeCoverage(v);
172375 if( regEnd ) sqlite3VdbeJumpHere(v, addr);
172381 sqlite3VdbeResolveLabel(v, lblWhereEnd);
172386 addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
172387 sqlite3VdbeJumpHere(v, addrGosubFlush);
172391 addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
172392 VdbeCoverage(v);
172405 addrStart = sqlite3VdbeCurrentAddr(v);
172410 addrStart = sqlite3VdbeCurrentAddr(v);
172415 addrStart = sqlite3VdbeCurrentAddr(v);
172419 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
172420 sqlite3VdbeJumpHere(v, addrBreak2);
172421 addrStart = sqlite3VdbeCurrentAddr(v);
172423 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
172424 sqlite3VdbeJumpHere(v, addrBreak1);
172425 sqlite3VdbeJumpHere(v, addrBreak3);
172430 addrStart = sqlite3VdbeCurrentAddr(v);
172433 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
172434 sqlite3VdbeJumpHere(v, addrBreak);
172436 sqlite3VdbeJumpHere(v, addrEmpty);
172438 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
172441 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
172442 sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
172444 sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v));
172445 sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
178174 'T','E','M','P','O','R','A','R','Y','I','S','N','U','L','L','S','A','V',
178178 'C','L','U','S','I','V','E','X','I','S','T','S','C','O','N','S','T','R',
178180 'G','E','N','E','R','A','T','E','D','E','T','A','C','H','A','V','I','N',
178190 'I','S','T','I','N','C','T','U','P','D','A','T','E','V','A','L','U','E',
178191 'S','V','I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H',
178192 'E','R','E','C','U','R','S','I','V','E','A','B','O','R','T','A','F','T',
178201 'I','C','T','O','T','H','E','R','S','O','V','E','R','E','T','U','R','N',
178204 'I','N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W',
181037 ** SQL statements below, as the v-table implementation may be storing
184583 sqlite3_int64 v;
184584 if( z && sqlite3DecOrHexToI64(z, &v)==0 ){
184585 bDflt = v;
186487 SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){
186489 sqlite_uint64 vu = v;
186499 #define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \
186500 v = (v & mask1) | ( (*(const unsigned char*)(ptr++)) << shift ); \
186501 if( (v & mask2)==0 ){ var = v; return ret; }
186502 #define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \
186503 v = (*ptr++); \
186504 if( (v & mask2)==0 ){ var = v; return ret; }
186506 SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *pBuf, sqlite_uint64 *v){
186513 GETVARINT_INIT(a, p, 0, 0x00, 0x80, *v, 1);
186514 GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *v, 2);
186515 GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *v, 3);
186516 GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4);
186524 *v = b;
186531 ** The value is stored in *v.
186533 SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *pBuf, sqlite_int64 *v){
186534 return sqlite3Fts3GetVarintU(pBuf, (sqlite3_uint64*)v);
186541 ** The value is stored in *v.
186546 sqlite_int64 *v
186559 *v = b;
186589 ** Return the number of bytes required to encode v as a varint
186591 SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64 v){
186595 v >>= 7;
186596 }while( v!=0 );
192645 sqlite3_int64 v = 0;
192647 i += sqlite3Fts3GetVarint(&aDoclist[i], &v);
192666 if( v>1 ){
192673 if( v==0 ){ /* 0x00. Next integer will be a docid. */
192675 }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
192685 iCol = (int)v;
193019 return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f';
194754 ** Let any sequence of one or more vowels be represented by V and let
194758 ** [C] (VC){m} [V]
195126 case 'v':
201926 int v;
201928 v = atoi(&zVal[9]);
201929 if( v>=24 && v<=p->nPgsz-35 ) p->nNodeSize = v;
201932 v = atoi(&zVal[11]);
201933 if( v>=64 && v<=FTS3_MAX_PENDING_DATA ) p->nMaxPendingData = v;
201939 v = atoi(&zVal[11]);
201940 if( v>=4 && v<=FTS3_MERGE_COUNT && (v&1)==0 ) p->nMergeCount = v;
204665 's'|HIBIT, 't', 'u', 'u'|HIBIT, 'v', 'w',
205747 u32 v;
205748 v = (jsonHexToInt(z[0])<<12)
205752 return v;
206559 }else if( c=='\'' || c=='0' || c=='v' || c=='\n'
207098 case 'v':
207446 u32 v, vlo;
207451 v = jsonHexToInt4(&z[2]);
207452 if( (v & 0xfc00)==0xd800
207458 *piOut = ((v&0x3ff)<<10) + (vlo&0x3ff) + 0x10000;
207461 *piOut = v;
207470 case 'v': { *piOut = '\v'; return 2; }
207735 u32 v = k+sz; /* v is the index of the value */
207736 if( ((pParse->aBlob[v])&0x0f)>JSONB_OBJECT ) return JSON_LOOKUP_ERROR;
207737 n = jsonbPayloadSize(pParse, v, &sz);
207738 if( n==0 || v+n+sz>iEnd ) return JSON_LOOKUP_ERROR;
207740 rc = jsonLookupStep(pParse, v, &zPath[i], j);
207753 JsonParse v; /* BLOB encoding of the value to be inserted */
207761 rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i]);
207763 && jsonBlobMakeEditable(pParse, ix.nBlob+nKey+v.nBlob)
207766 nIns = ix.nBlob + nKey + v.nBlob;
207775 memcpy(&pParse->aBlob[k], v.aBlob, v.nBlob);
207779 jsonParseReset(&v);
207830 JsonParse v;
207833 rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i+1]);
207835 && jsonBlobMakeEditable(pParse, v.nBlob)
207838 jsonBlobEdit(pParse, j, 0, v.aBlob, v.nBlob);
207840 jsonParseReset(&v);
207974 u32 v;
207975 u32 szEscape = jsonUnescapeOneChar(&z[iIn], sz-iIn, &v);
207976 if( v<=0x7f ){
207977 zOut[iOut++] = (char)v;
207978 }else if( v<=0x7ff ){
207980 zOut[iOut++] = (char)(0xc0 | (v>>6));
207981 zOut[iOut++] = 0x80 | (v&0x3f);
207982 }else if( v<0x10000 ){
207984 zOut[iOut++] = 0xe0 | (v>>12);
207985 zOut[iOut++] = 0x80 | ((v>>6)&0x3f);
207986 zOut[iOut++] = 0x80 | (v&0x3f);
207987 }else if( v==JSON_INVALID_CHAR ){
207991 zOut[iOut++] = 0xf0 | (v>>18);
207992 zOut[iOut++] = 0x80 | ((v>>12)&0x3f);
207993 zOut[iOut++] = 0x80 | ((v>>6)&0x3f);
207994 zOut[iOut++] = 0x80 | (v&0x3f);
213326 static RtreeValue rtreeValueDown(sqlite3_value *v){
213327 double d = sqlite3_value_double(v);
213334 static RtreeValue rtreeValueUp(sqlite3_value *v){
213335 double d = sqlite3_value_double(v);
215424 int v = 0;
215431 v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),
215433 if( v==2 ) break;
215434 cnt += v;
215436 if( v!=2 ){
215437 v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),
215440 if( v==2 ){
215442 }else if( ((v+cnt)&1)==0 ){
216637 ** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $
218305 "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)"
218617 unsigned int v = 0;
218622 v = (v<<6) + c;
218627 return v;
220822 sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb)
221664 "INSERT OR REPLACE INTO %s.rbu_state(k, v) VALUES "
227337 static void sessionAppendByte(SessionBuffer *p, u8 v, int *pRc){
227339 p->aBuf[p->nBuf++] = v;
227350 static void sessionAppendVarint(SessionBuffer *p, int v, int *pRc){
227352 p->nBuf += sessionVarintPut(&p->aBuf[p->nBuf], v);
228376 sqlite3_int64 v = sessionGetI64(aVal);
228378 sqlite3VdbeMemSetInt64(apOut[i], v);
228381 memcpy(&d, &v, 8);
232610 static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v);
232613 static int sqlite3Fts5PutVarint(unsigned char *p, u64 v);
236614 const char *zSelect = "SELECT k, v FROM %Q.'%q_config'";
248441 # define fts5TestTerm(u,v,w,x,y,z)
253053 pConfig, "config", "k PRIMARY KEY, v", 1, pzErr
254672 /* porter rule condition: (*v*) */
254802 case 'v':
255048 case 'v':
255472 's'|HIBIT, 't', 'u', 'u'|HIBIT, 'v', 'w',
255827 3570, 3572, 3585, 3633, 3634, 3636, 3647, 3648, 3654, 3655,
256207 static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v){
256216 *v = a;
256229 *v = a | b;
256244 *v = a | b;
256262 *v = ((u32)v64) & 0x7FFFFFFF;
256283 ** Return the number of bytes read. The value is stored in *v.
256285 static u8 sqlite3Fts5GetVarint(const unsigned char *p, u64 *v){
256292 *v = a;
256304 *v = a;
256322 *v = a;
256339 *v = a;
256364 *v = ((u64)s)<<32 | a;
256385 *v = ((u64)s)<<32 | a;
256400 *v = ((u64)s)<<32 | a;
256418 *v = ((u64)s)<<32 | a;
256439 *v = ((u64)s)<<32 | a;
256479 static int FTS5_NOINLINE fts5PutVarint64(unsigned char *p, u64 v){
256482 if( v & (((u64)0xff000000)<<32) ){
256483 p[8] = (u8)v;
256484 v >>= 8;
256486 p[i] = (u8)((v & 0x7f) | 0x80);
256487 v >>= 7;
256493 buf[n++] = (u8)((v & 0x7f) | 0x80);
256494 v >>= 7;
256495 }while( v!=0 );
256504 static int sqlite3Fts5PutVarint(unsigned char *p, u64 v){
256505 if( v<=0x7f ){
256506 p[0] = v&0x7f;
256509 if( v<=0x3fff ){
256510 p[0] = ((v>>7)&0x7f)|0x80;
256511 p[1] = v&0x7f;
256514 return fts5PutVarint64(p,v);