Lines Matching +full:976 +full:v
2034 ** The second argument to sqlite3_db_config(D,V,...) is the
6224 ** ^If [sqlite3_value] object V was initialized
6227 ** then sqlite3_value_pointer(V,Y) will return the pointer P. ^Otherwise,
6228 ** sqlite3_value_pointer(V,Y) returns a NULL. The sqlite3_bind_pointer()
6231 ** ^(The sqlite3_value_type(V) interface returns the
6233 ** [sqlite3_value] object V. The returned value is one of [SQLITE_INTEGER],
6237 ** sqlite3_value_text(V) is called to extract a text value for that
6238 ** integer, then subsequent calls to sqlite3_value_type(V) might return
6341 ** The sqlite3_value_subtype(V) function returns the subtype for
6342 ** an [application-defined SQL function] argument V. The subtype
6359 ** ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value]
6360 ** object V and returns a pointer to that copy. ^The [sqlite3_value] returned
6362 ** ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a
6363 ** memory allocation fails. ^If V is a [pointer value], then the result
6364 ** of sqlite3_value_dup(V) is a NULL value.
6366 ** ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object
6367 ** previously obtained from [sqlite3_value_dup()]. ^If V is a NULL pointer
6368 ** then sqlite3_value_free(V) is a harmless no-op.
9005 ** [sqlite3_str_vappendf(X,F,V)] interfaces uses the [built-in printf]
10679 ** ^When the sqlite3_vtab_rhs_value(P,J,V) interface is invoked from within
10683 ** attempts to set *V to the value of the right-hand operand of
10685 ** right-hand operand is not known, then *V is set to a NULL pointer.
10686 ** ^The sqlite3_vtab_rhs_value(P,J,V) interface returns SQLITE_OK if
10687 ** and only if *V is set to a value. ^The sqlite3_vtab_rhs_value(P,J,V)
10703 ** ^The [sqlite3_value] object returned in *V is a protected sqlite3_value
10736 ** [sqlite3_stmt_scanstatus(S,X,T,V)] interface. Each constant designates a
10739 ** When the value returned to V is a string, space to hold that string is
10749 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be
10753 ** <dd>^The [sqlite3_int64] variable pointed to by the V parameter will be set
10757 ** <dd>^The "double" variable pointed to by the V parameter will be set to the
10765 ** <dd>^The "const char *" variable pointed to by the V parameter will be set
10770 ** <dd>^The "const char *" variable pointed to by the V parameter will be set
10775 ** <dd>^The "int" variable pointed to by the V parameter will be set to the
10781 ** <dd>The "int" variable pointed to by the V parameter will be set to the
15703 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) argument
15709 #define GLOBAL(t,v) v argument
17334 # define ExplainQueryPlan2(V,P) (V = sqlite3VdbeExplain P) argument
17336 # define ExplainQueryPlan2(V,P) ExplainQueryPlan(P) argument
17342 # define ExplainQueryPlan2(V,P) argument
17457 ** VdbeCoverage(v) // Mark the previously coded instruction
17460 ** VdbeCoverageIf(v, conditional) // Mark previous if conditional true
17462 ** VdbeCoverageAlwaysTaken(v) // Previous branch is always taken
17464 ** VdbeCoverageNeverTaken(v) // Previous branch is never taken
17466 ** VdbeCoverageNeverNull(v) // Previous three-way branch is only
17470 ** VdbeCoverageEqNe(v) // Previous OP_Jump is only interested
17491 # define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__) argument
17492 # define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__) argument
17493 # define VdbeCoverageAlwaysTaken(v) \ argument
17494 sqlite3VdbeSetLineNumber(v,__LINE__|0x5000000);
17495 # define VdbeCoverageNeverTaken(v) \ argument
17496 sqlite3VdbeSetLineNumber(v,__LINE__|0x6000000);
17497 # define VdbeCoverageNeverNull(v) \ argument
17498 sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000);
17499 # define VdbeCoverageNeverNullIf(v,x) \ argument
17500 if(x)sqlite3VdbeSetLineNumber(v,__LINE__|0x4000000);
17501 # define VdbeCoverageEqNe(v) \ argument
17502 sqlite3VdbeSetLineNumber(v,__LINE__|0x8000000);
17505 # define VdbeCoverage(v) argument
17506 # define VdbeCoverageIf(v,x) argument
17507 # define VdbeCoverageAlwaysTaken(v) argument
17508 # define VdbeCoverageNeverTaken(v) argument
17509 # define VdbeCoverageNeverNull(v) argument
17510 # define VdbeCoverageNeverNullIf(v,x) argument
17511 # define VdbeCoverageEqNe(v) argument
21683 SQLITE_PRIVATE int sqlite3VarintLen(u64 v);
21926 #define sqlite3TableLock(v,w,x,y,z) argument
22033 #define sqlite3UpsertNew(u,v,w,x,y,z) ((Upsert*)0) argument
23776 Vdbe *v; /* VM this frame belongs to */ member
24124 Vdbe *v; member
24282 # define sqlite3VdbeIncrWriteCounter(V,C) argument
24283 # define sqlite3VdbeAssertAbortable(V) argument
26090 ** %G ISO year corresponding to %V 0000-9999.
26091 ** %g 2-digit ISO year corresponding to %V 00-99
26109 ** %V week of year 01-53 (First week containing Thursday is week 01)
26244 case 'V': { /* Week num. 01-53. First week with a Thur is week 01 */ in strftimeFunc()
32034 i64 v; in sqlite3_str_vappendf() local
32036 v = getIntArg(pArgList); in sqlite3_str_vappendf()
32039 v = va_arg(ap,i64) ; in sqlite3_str_vappendf()
32041 v = va_arg(ap,long int); in sqlite3_str_vappendf()
32044 v = va_arg(ap,int); in sqlite3_str_vappendf()
32046 if( v<0 ){ in sqlite3_str_vappendf()
32047 testcase( v==SMALLEST_INT64 ); in sqlite3_str_vappendf()
32048 testcase( v==(-1) ); in sqlite3_str_vappendf()
32049 longvalue = ~v; in sqlite3_str_vappendf()
32053 longvalue = v; in sqlite3_str_vappendf()
35019 ** Write a single UTF8 character whose value is v into the
35024 SQLITE_PRIVATE int sqlite3AppendOneUtf8Character(char *zOut, u32 v){ in sqlite3AppendOneUtf8Character() argument
35025 if( v<0x00080 ){ in sqlite3AppendOneUtf8Character()
35026 zOut[0] = (u8)(v & 0xff); in sqlite3AppendOneUtf8Character()
35029 if( v<0x00800 ){ in sqlite3AppendOneUtf8Character()
35030 zOut[0] = 0xc0 + (u8)((v>>6) & 0x1f); in sqlite3AppendOneUtf8Character()
35031 zOut[1] = 0x80 + (u8)(v & 0x3f); in sqlite3AppendOneUtf8Character()
35034 if( v<0x10000 ){ in sqlite3AppendOneUtf8Character()
35035 zOut[0] = 0xe0 + (u8)((v>>12) & 0x0f); in sqlite3AppendOneUtf8Character()
35036 zOut[1] = 0x80 + (u8)((v>>6) & 0x3f); in sqlite3AppendOneUtf8Character()
35037 zOut[2] = 0x80 + (u8)(v & 0x3f); in sqlite3AppendOneUtf8Character()
35040 zOut[0] = 0xf0 + (u8)((v>>18) & 0x07); in sqlite3AppendOneUtf8Character()
35041 zOut[1] = 0x80 + (u8)((v>>12) & 0x3f); in sqlite3AppendOneUtf8Character()
35042 zOut[2] = 0x80 + (u8)((v>>6) & 0x3f); in sqlite3AppendOneUtf8Character()
35043 zOut[3] = 0x80 + (u8)(v & 0x3f); in sqlite3AppendOneUtf8Character()
36239 SQLITE_PRIVATE int sqlite3Int64ToText(i64 v, char *zOut){ in sqlite3Int64ToText() argument
36243 if( v<0 ){ in sqlite3Int64ToText()
36244 x = (v==SMALLEST_INT64) ? ((u64)1)<<63 : (u64)-v; in sqlite3Int64ToText()
36246 x = v; in sqlite3Int64ToText()
36256 if( v<0 ) zTemp[--i] = '-'; in sqlite3Int64ToText()
36446 sqlite_int64 v = 0; in sqlite3GetInt32() local
36477 v = v*10 + c; in sqlite3GetInt32()
36489 testcase( v-neg==2147483647 ); in sqlite3GetInt32()
36490 if( v-neg>2147483647 ){ in sqlite3GetInt32()
36494 v = -v; in sqlite3GetInt32()
36496 *pValue = (int)v; in sqlite3GetInt32()
36529 u64 v; in sqlite3FpDecode() local
36551 memcpy(&v,&r,8); in sqlite3FpDecode()
36552 e = v>>52; in sqlite3FpDecode()
36554 p->isSpecial = 1 + (v!=0x7ff0000000000000LL); in sqlite3FpDecode()
36600 v = rr[1]<0.0 ? (u64)rr[0]-(u64)(-rr[1]) : (u64)rr[0]+(u64)rr[1]; in sqlite3FpDecode()
36604 assert( v>0 ); in sqlite3FpDecode()
36605 while( v ){ p->zBuf[i--] = (v%10) + '0'; v /= 10; } in sqlite3FpDecode()
36657 u64 v = 0; in sqlite3GetUInt32() local
36660 v = v*10 + z[i] - '0'; in sqlite3GetUInt32()
36661 if( v>4294967296LL ){ *pI = 0; return 0; } in sqlite3GetUInt32()
36664 *pI = (u32)v; in sqlite3GetUInt32()
36697 static int SQLITE_NOINLINE putVarint64(unsigned char *p, u64 v){ in putVarint64() argument
36700 if( v & (((u64)0xff000000)<<32) ){ in putVarint64()
36701 p[8] = (u8)v; in putVarint64()
36702 v >>= 8; in putVarint64()
36704 p[i] = (u8)((v & 0x7f) | 0x80); in putVarint64()
36705 v >>= 7; in putVarint64()
36711 buf[n++] = (u8)((v & 0x7f) | 0x80); in putVarint64()
36712 v >>= 7; in putVarint64()
36713 }while( v!=0 ); in putVarint64()
36721 SQLITE_PRIVATE int sqlite3PutVarint(unsigned char *p, u64 v){ in sqlite3PutVarint() argument
36722 if( v<=0x7f ){ in sqlite3PutVarint()
36723 p[0] = v&0x7f; in sqlite3PutVarint()
36726 if( v<=0x3fff ){ in sqlite3PutVarint()
36727 p[0] = ((v>>7)&0x7f)|0x80; in sqlite3PutVarint()
36728 p[1] = v&0x7f; in sqlite3PutVarint()
36731 return putVarint64(p,v); in sqlite3PutVarint()
36749 ** Return the number of bytes read. The value is stored in *v.
36751 SQLITE_PRIVATE u8 sqlite3GetVarint(const unsigned char *p, u64 *v){ in sqlite3GetVarint() argument
36755 *v = *p; in sqlite3GetVarint()
36759 *v = ((u32)(p[0]&0x7f)<<7) | p[1]; in sqlite3GetVarint()
36778 *v = a; in sqlite3GetVarint()
36795 *v = a; in sqlite3GetVarint()
36821 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36842 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36857 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36875 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36896 *v = ((u64)s)<<32 | a; in sqlite3GetVarint()
36903 ** Return the number of bytes read. The value is stored in *v.
36906 ** integer, then set *v to 0xffffffff.
36912 SQLITE_PRIVATE u8 sqlite3GetVarint32(const unsigned char *p, u32 *v){ in sqlite3GetVarint32() argument
36922 *v = ((p[0]&0x7f)<<7) | p[1]; in sqlite3GetVarint32()
36927 *v = ((p[0]&0x7f)<<14) | ((p[1]&0x7f)<<7) | p[2]; in sqlite3GetVarint32()
36934 *v = 0xffffffff; in sqlite3GetVarint32()
36936 *v = (u32)v64; in sqlite3GetVarint32()
36945 SQLITE_PRIVATE int sqlite3VarintLen(u64 v){ in sqlite3VarintLen() argument
36947 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); } in sqlite3VarintLen()
36973 SQLITE_PRIVATE void sqlite3Put4byte(unsigned char *p, u32 v){ in sqlite3Put4byte() argument
36975 memcpy(p,&v,4); in sqlite3Put4byte()
36977 u32 x = __builtin_bswap32(v); in sqlite3Put4byte()
36980 u32 x = _byteswap_ulong(v); in sqlite3Put4byte()
36983 p[0] = (u8)(v>>24); in sqlite3Put4byte()
36984 p[1] = (u8)(v>>16); in sqlite3Put4byte()
36985 p[2] = (u8)(v>>8); in sqlite3Put4byte()
36986 p[3] = (u8)v; in sqlite3Put4byte()
55052 ** Let V[] be an array of unsigned characters sufficient to hold
55055 ** individual bits within V.
55057 #define SETBIT(V,I) V[I>>3] |= (1<<(I&7)) argument
55058 #define CLEARBIT(V,I) V[I>>3] &= ~(BITVEC_TELEM)(1<<(I&7)) argument
55059 #define TESTBIT(V,I) (V[I>>3]&(1<<(I&7)))!=0 argument
57471 ** in the list, pLeft points to the tree, and v is unused. The
57475 i64 v; /* ROWID value for this entry */ member
57607 pEntry->v = rowid;
57611 if( rowid<=pLast->v ){ /*OPTIMIZATION-IF-FALSE*/
57639 assert( pA->pRight==0 || pA->v<=pA->pRight->v );
57640 assert( pB->pRight==0 || pB->v<=pB->pRight->v );
57641 if( pA->v<=pB->v ){
57642 if( pA->v<pB->v ) pTail = pTail->pRight = pA;
57662 ** increasing v.
57810 *pRowid = p->pEntry->v;
57862 pTree->v = 0;
57880 if( p->v<iRowid ){
57882 }else if( p->v>iRowid ){
57948 # define sqlite3WalClose(v,w,x,y,z) 0 argument
57957 # define sqlite3WalFrames(u,v,w,x,y,z) 0 argument
57958 # define sqlite3WalCheckpoint(q,r,s,t,u,v,w,x,y,z) 0 argument
58198 ** V | |
58201 ** | V |
58204 ** | V |
58207 ** | V |
58210 ** | V |
58784 # define PAGER_INCR(v) v++ argument
58786 # define PAGER_INCR(v) argument
58888 # define pagerWalFrames(v,w,x,y) 0 argument
70632 ** | | v
71238 #define put2byte(p,v) ((p)[0] = (u8)((v)>>8), (p)[1] = (u8)(v)) argument
85667 Vdbe *v; local
85670 if( (v = pParse->pReprepare)!=0 ){
85673 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
85847 sqlite3_value *v, /* Value to be set */
85853 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
85859 SQLITE_PRIVATE void sqlite3ValueFree(sqlite3_value *v){
85860 if( !v ) return;
85861 sqlite3VdbeMemRelease((Mem *)v);
85862 sqlite3DbFreeNN(((Mem*)v)->db, v);
86058 static int growOpArray(Vdbe *v, int nOp){
86060 Parse *p = v->pParse;
86070 sqlite3_int64 nNew = (v->nOpAlloc>=512 ? 2*(sqlite3_int64)v->nOpAlloc
86071 : (sqlite3_int64)v->nOpAlloc+nOp);
86073 sqlite3_int64 nNew = (v->nOpAlloc ? 2*(sqlite3_int64)v->nOpAlloc
86085 assert( nNew>=(v->nOpAlloc+nOp) );
86086 pNew = sqlite3DbRealloc(p->db, v->aOp, nNew*sizeof(Op));
86089 v->nOpAlloc = p->szOpAlloc/sizeof(Op);
86090 v->aOp = pNew;
86341 Vdbe *v = pParse->pVdbe; local
86344 assert( v );
86356 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
86357 addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
86359 sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
86420 Vdbe *v; local
86426 v = pParse->pVdbe;
86427 iThis = v->nOp;
86428 addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
86430 sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetLastOp(v)->p4.z);
86434 sqlite3VdbeScanStatus(v, iThis, -1, -1, 0, 0);
86466 SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
86467 sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
86475 v->pParse->nTempReg = 0;
86476 v->pParse->nRangeReg = 0;
86513 static SQLITE_NOINLINE void resizeResolveLabel(Parse *p, Vdbe *v, int j){
86528 p->aLabel[j] = v->nOp;
86531 SQLITE_PRIVATE void sqlite3VdbeResolveLabel(Vdbe *v, int x){
86532 Parse *p = v->pParse;
86534 assert( v->eVdbeState==VDBE_INIT_STATE );
86539 printf("RESOLVE LABEL %d to %d\n", x, v->nOp);
86543 resizeResolveLabel(p,v,j);
86546 p->aLabel[j] = v->nOp;
86581 ** sIter.v = v; // v is of type Vdbe*
86585 ** sqlite3DbFree(v->db, sIter.apSub);
86590 Vdbe *v; /* Vdbe to iterate through the opcodes of */ member
86597 Vdbe *v = p->v; local
86605 aOp = v->aOp;
86606 nOp = v->nOp;
86627 p->apSub = sqlite3DbReallocOrFree(v->db, p->apSub, nByte);
86663 SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
86672 if( v==0 ) return 0;
86674 sIter.v = v;
86705 sqlite3DbFree(v->db, sIter.apSub);
86712 return ( v->db->mallocFailed || hasAbort==mayAbort || hasFkCounter
86890 Vdbe *v, /* The byte-code program under construction */
86899 assert( v!=0 );
86900 pParse = v->pParse;
86904 assert( iLast<v->nOp );
86905 pOp = &v->aOp[iFirst];
86925 for(; j<v->nOp; j++){
86926 VdbeOp *pX = &v->aOp[j];
86949 sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_INTERNAL, OE_Abort, 0, zErr, 0);
87524 Vdbe *v = pParse->pVdbe; local
87526 assert( v!=0 );
87529 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
87571 SQLITE_PRIVATE void sqlite3VdbeSetLineNumber(Vdbe *v, int iLine){
87572 sqlite3VdbeGetLastOp(v)->iSrcLine = iLine;
88140 pFrame->pParent = pFrame->v->pDelFrame;
88141 pFrame->v->pDelFrame = pFrame;
88270 if( apCsr[i] ) sqlite3VdbeFreeCursorNN(p->v, apCsr[i]);
88273 sqlite3VdbeDeleteAuxData(p->v->db, &p->pAuxData, -1, 0);
88274 sqlite3DbFree(p->v->db, p);
88703 Vdbe *v = pFrame->v; local
88704 closeCursorsInFrame(v);
88705 v->aOp = pFrame->aOp;
88706 v->nOp = pFrame->nOp;
88707 v->aMem = pFrame->aMem;
88708 v->nMem = pFrame->nMem;
88709 v->apCsr = pFrame->apCsr;
88710 v->nCursor = pFrame->nCursor;
88711 v->db->lastRowid = pFrame->lastRowid;
88712 v->nChange = pFrame->nChange;
88713 v->db->nChange = pFrame->nDbChange;
88714 sqlite3VdbeDeleteAuxData(v->db, &v->pAuxData, -1, 0);
88715 v->pAuxData = pFrame->pAuxData;
89442 static void vdbeInvokeSqllog(Vdbe *v){
89443 if( sqlite3GlobalConfig.xSqllog && v->rc==SQLITE_OK && v->zSql && v->pc>=0 ){
89444 char *zExpanded = sqlite3VdbeExpandSql(v, v->zSql);
89445 assert( v->db->init.busy==0 );
89448 sqlite3GlobalConfig.pSqllogArg, v->db, zExpanded, 1
89450 sqlite3DbFree(v->db, zExpanded);
90861 i64 v; local
90921 v = pPKey2->u.i;
90922 if( v>lhs ){
90924 }else if( v<lhs ){
91077 Mem m, v; local
91126 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
91127 *rowid = v.u.i;
91195 SQLITE_PRIVATE void sqlite3VdbeCountChanges(Vdbe *v){
91196 v->changeCntOn = 1;
91227 SQLITE_PRIVATE sqlite3 *sqlite3VdbeDb(Vdbe *v){
91228 return v->db;
91234 SQLITE_PRIVATE u8 sqlite3VdbePrepareFlags(Vdbe *v){
91235 return v->prepFlags;
91240 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
91246 SQLITE_PRIVATE sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe *v, int iVar, u8 aff){
91248 if( v ){
91249 Mem *pMem = &v->aVar[iVar-1];
91250 assert( (v->db->flags & SQLITE_EnableQPSG)==0
91251 || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
91253 sqlite3_value *pRet = sqlite3ValueNew(v->db);
91269 SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
91271 assert( (v->db->flags & SQLITE_EnableQPSG)==0
91272 || (v->db->mDbFlags & DBFLAG_InternalFunc)!=0 );
91274 v->expmask |= 0x80000000;
91276 v->expmask |= ((u32)1 << (iVar-1));
91376 Vdbe *v, /* Vdbe pre-update hook is invoked by */
91385 sqlite3 *db = v->db;
91408 iKey2 = v->aMem[iReg].u.i;
91420 preupdate.v = v;
91565 Vdbe *v = (Vdbe*)pStmt; local
91566 sqlite3 *db = v->db;
91567 if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
91569 checkProfileCallback(db, v);
91570 assert( v->eVdbeState>=VDBE_READY_STATE );
91571 rc = sqlite3VdbeReset(v);
91572 sqlite3VdbeDelete(v);
91592 Vdbe *v = (Vdbe*)pStmt; local
91593 sqlite3 *db = v->db;
91595 checkProfileCallback(db, v);
91596 rc = sqlite3VdbeReset(v);
91597 sqlite3VdbeRewind(v);
92356 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */ local
92360 if( vdbeSafetyNotNull(v) ){
92363 db = v->db;
92365 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
92367 int savedPc = v->pc;
92368 rc = sqlite3Reprepare(v);
92379 sqlite3DbFree(db, v->zErrMsg);
92381 v->zErrMsg = sqlite3DbStrDup(db, zErr);
92382 v->rc = rc = sqlite3ApiExit(db, rc);
92384 v->zErrMsg = 0;
92385 v->rc = rc = SQLITE_NOMEM_BKPT;
92395 v->minWriteFileFormat = 254;
92397 assert( v->expired==0 );
93464 Vdbe *v = (Vdbe*)pStmt; local
93469 sqlite3_mutex_enter(v->db->mutex);
93470 if( ((int)v->explain)==eMode ){
93474 }else if( (v->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
93476 }else if( v->eVdbeState!=VDBE_READY_STATE ){
93478 }else if( v->nMem>=10 && (eMode!=2 || v->haveEqpOps) ){
93480 v->explain = eMode;
93483 v->explain = eMode;
93484 rc = sqlite3Reprepare(v);
93485 v->haveEqpOps = eMode==2;
93487 if( v->explain ){
93488 v->nResColumn = 12 - 4*v->explain;
93490 v->nResColumn = v->nResAlloc;
93492 sqlite3_mutex_leave(v->db->mutex);
93500 Vdbe *v = (Vdbe*)pStmt; local
93501 return v!=0 && v->eVdbeState==VDBE_RUN_STATE;
93533 u32 v; local
93545 v = 0;
93546 db->pnBytesFreed = (int*)&v;
93554 v = pVdbe->aCounter[op];
93557 return (int)v;
93766 return (p ? p->v->nFrame : 0);
93823 Mem *pData = &p->v->aMem[p->iNewReg];
93860 rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iStore]);
94482 static void test_trace_breakpoint(int pc, Op *pOp, Vdbe *v){
94486 (void)v;
94967 SQLITE_PRIVATE void sqlite3VdbeRegisterDump(Vdbe *v){
94969 for(i=1; i<v->nMem; i++) registerTrace(i, v->aMem+i);
98015 u64 v;
98017 assert( sizeof(v)==sizeof(pRec->u.r) );
98018 memcpy(&v, &pRec->u.r, sizeof(v));
98019 swapMixedEndianFloat(v);
98021 v = pRec->u.i;
98026 default: zPayload[7] = (u8)(v&0xff); v >>= 8;
98027 zPayload[6] = (u8)(v&0xff); v >>= 8;
98029 case 6: zPayload[5] = (u8)(v&0xff); v >>= 8;
98030 zPayload[4] = (u8)(v&0xff); v >>= 8;
98032 case 4: zPayload[3] = (u8)(v&0xff); v >>= 8;
98034 case 3: zPayload[2] = (u8)(v&0xff); v >>= 8;
98036 case 2: zPayload[1] = (u8)(v&0xff); v >>= 8;
98038 case 1: zPayload[0] = (u8)(v&0xff);
98462 ** Often, v-tables store their data in other SQLite tables, which
98463 ** are queried from within xNext() and other v-table methods using
98466 ** v-table would have to be ready for the sqlite3_vtab structure itself
98468 ** a v-table method.
99872 i64 v; /* The new rowid */
99881 v = 0;
99922 v = 1; /* IMP: R-61914-48074 */
99925 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
99926 if( v>=MAX_ROWID ){
99929 v++; /* IMP: R-29538-34987 */
99958 if( v<pMem->u.i+1 ){
99959 v = pMem->u.i + 1;
99961 pMem->u.i = v;
99973 sqlite3_randomness(sizeof(v), &v);
99974 v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */
99975 }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
99984 assert( v>0 ); /* EV: R-40812-03570 */
99989 pOut->u.i = v;
100438 i64 v;
100451 v = pC->movetoTarget;
100458 rc = pModule->xRowid(pC->uc.pVCur, &v);
100471 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
100473 pOut->u.i = v;
101736 pFrame->v = p;
103633 Vdbe *v = (Vdbe *)p->pStmt;
103638 sqlite3VdbeMemSetInt64(&v->aMem[1], iRow);
103644 if( v->pc>4 ){
103645 v->pc = 4;
103646 assert( v->aOp[v->pc].opcode==OP_NotExists );
103647 rc = sqlite3VdbeExec(v);
103652 VdbeCursor *pC = v->apCsr[0];
103855 Vdbe *v = (Vdbe *)pBlob->pStmt;
103858 sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, wrFlag,
103861 sqlite3VdbeChangeP5(v, 1);
103862 assert( sqlite3VdbeCurrentAddr(v)==2 || db->mallocFailed );
103863 aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
103866 sqlite3VdbeUsesBtree(v, iDb);
103877 sqlite3VdbeChangeP4(v, 2, pTab->zName, P4_TRANSIENT);
103902 sqlite3VdbeMakeReady(v, &sParse);
103966 Vdbe *v;
103972 v = (Vdbe*)p->pStmt;
103977 }else if( v==0 ){
103986 assert( db == v->db );
104006 assert( v->apCsr[0]!=0 );
104007 assert( v->apCsr[0]->eCurType==CURTYPE_BTREE );
104009 v, v->apCsr[0], SQLITE_DELETE, p->zDb, p->pTab, iKey, -1, p->iCol
104017 sqlite3VdbeFinalize(v);
104020 v->rc = rc;
105537 ** v */
111048 Vdbe *v = pParse->pVdbe;
111083 sqlite3VdbeAddOp2(v, OP_Integer, 1, dest);
111089 if( addrCmp ) sqlite3VdbeJumpHere(v, addrCmp);
111092 addrCmp = sqlite3VdbeCurrentAddr(v);
111094 testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
111095 testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
111096 testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
111097 testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
111098 testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
111099 testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
111103 addrCmp = sqlite3VdbeAddOp0(v, OP_ElseEq);
111104 testcase(opx==TK_LT); VdbeCoverageIf(v,opx==TK_LT);
111105 testcase(opx==TK_GT); VdbeCoverageIf(v,opx==TK_GT);
111108 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest);
111110 sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, dest, r2);
111116 sqlite3VdbeAddOp2(v, OP_NotNull, dest, addrDone); VdbeCoverage(v);
111119 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
111123 sqlite3VdbeJumpHere(v, addrCmp);
111124 sqlite3VdbeResolveLabel(v, addrDone);
111126 sqlite3VdbeAddOp2(v, OP_Not, dest, dest);
112668 u32 v;
112671 && (v = sqlite3IsTrueOrFalse(pExpr->u.zToken))!=0
112674 ExprSetProperty(pExpr, v);
113172 int v = 0;
113173 if( sqlite3ExprIsInteger(p->pLeft, &v, 0) ){
113174 assert( ((unsigned int)v)!=0x80000000 );
113175 *pValue = -v;
113371 static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){
113373 sqlite3VdbeAddOp2(v, OP_Integer, 0, regHasNull);
113374 addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
113375 sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull);
113376 sqlite3VdbeChangeP5(v, OPFLAG_TYPEOFARG);
113377 VdbeComment((v, "first_entry_in(%d)", iCur));
113378 sqlite3VdbeJumpHere(v, addr1);
113496 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
113539 assert(v); /* sqlite3GetVdbe() has always been previously called */
113542 int iAddr = sqlite3VdbeAddOp0(v, OP_Once);
113543 VdbeCoverage(v);
113549 sqlite3VdbeJumpHere(v, iAddr);
113627 int iAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
113630 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
113632 VdbeComment((v, "%s", pIdx->zName));
113639 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed,
113644 sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull);
113647 sqlite3VdbeJumpHere(v, iAddr);
113686 sqlite3SetHasNullFlag(v, iTab, rMayHaveNull);
113785 Vdbe *v;
113794 v = pParse->pVdbe;
113795 assert( v!=0 );
113796 pOp = sqlite3VdbeGetOp(v, 1);
113797 pEnd = sqlite3VdbeGetLastOp(v);
113849 Vdbe *v; /* The prepared statement under construction */
113852 v = pParse->pVdbe;
113853 assert( v!=0 );
113887 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
113893 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
113896 sqlite3VdbeAddOp2(v, OP_OpenDup, iTab, pExpr->iTable);
113897 sqlite3VdbeJumpHere(v, addrOnce);
113911 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
113918 sqlite3VdbeChangeP4(v, -1, (const char*)pSig, P4_SUBRTNSIG);
113920 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
113931 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pExpr->iTable, nVal);
113934 VdbeComment((v, "Result of SELECT %u", pExpr->x.pSelect->selId));
113936 VdbeComment((v, "RHS of IN operator"));
113966 addrBloom = sqlite3VdbeAddOp2(v, OP_Blob, 10000, regBloom);
113967 VdbeComment((v, "Bloom filter"));
113979 sqlite3VdbeGetOp(v, addrOnce)->p3 = dest.iSDParm2;
113982 sqlite3VdbeGetOp(v, addrBloom)->p1 = 10;
114036 sqlite3VdbeChangeToNoop(v, addrOnce-1);
114037 sqlite3VdbeChangeToNoop(v, addrOnce);
114044 sqlite3VdbeAddOp4(v, OP_MakeRecord, r1, 1, r2, &affinity, 1);
114045 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r2, r1, 1);
114052 sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
114055 sqlite3VdbeAddOp1(v, OP_NullRow, iTab);
114056 sqlite3VdbeJumpHere(v, addrOnce);
114059 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
114061 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
114063 VdbeCoverage(v);
114095 Vdbe *v = pParse->pVdbe;
114096 assert( v!=0 );
114109 sqlite3VdbeAddOp2(v, OP_Gosub, pExpr->y.sub.regReturn,
114120 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pExpr->y.sub.regReturn) + 1;
114133 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
114148 sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, -1);
114156 sqlite3VdbeAddOp3(v, OP_Null, 0, dest.iSDParm, dest.iSDParm+nReg-1);
114157 VdbeComment((v, "Init subquery result"));
114160 sqlite3VdbeAddOp2(v, OP_Integer, 0, dest.iSDParm);
114161 VdbeComment((v, "Init EXISTS result"));
114189 sqlite3VdbeJumpHere(v, addrOnce);
114191 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
114195 assert( sqlite3VdbeGetOp(v,pExpr->y.sub.iAddr-1)->opcode==OP_BeginSubrtn
114197 sqlite3VdbeAddOp3(v, OP_Return, pExpr->y.sub.regReturn,
114199 VdbeCoverage(v);
114263 Vdbe *v; /* Statement under construction */
114290 v = pParse->pVdbe;
114291 assert( v!=0 ); /* OOM detected prior to this routine */
114292 VdbeNoopComment((v, "begin IN expr"));
114335 sqlite3VdbeAddOp3(v, OP_Copy, rLhsOrig+i, rLhs+aiMap[i], 0);
114357 sqlite3VdbeAddOp3(v, OP_BitAnd, rLhs, rLhs, regCkNull);
114362 sqlite3VdbeAddOp3(v, OP_BitAnd, regCkNull, r2, regCkNull);
114367 sqlite3VdbeAddOp4(v, op, rLhs, labelOk, r2,
114369 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_Eq);
114370 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_Eq);
114371 VdbeCoverageIf(v, ii<pList->nExpr-1 && op==OP_NotNull);
114372 VdbeCoverageIf(v, ii==pList->nExpr-1 && op==OP_NotNull);
114373 sqlite3VdbeChangeP5(v, zAff[0]);
114377 sqlite3VdbeAddOp4(v, op, rLhs, destIfFalse, r2,
114379 VdbeCoverageIf(v, op==OP_Ne);
114380 VdbeCoverageIf(v, op==OP_IsNull);
114381 sqlite3VdbeChangeP5(v, zAff[0] | SQLITE_JUMPIFNULL);
114385 sqlite3VdbeAddOp2(v, OP_IsNull, regCkNull, destIfNull); VdbeCoverage(v);
114386 sqlite3VdbeGoto(v, destIfFalse);
114388 sqlite3VdbeResolveLabel(v, labelOk);
114406 sqlite3VdbeAddOp2(v, OP_IsNull, rLhs+i, destStep2);
114407 VdbeCoverage(v);
114419 sqlite3VdbeAddOp3(v, OP_SeekRowid, iTab, destIfFalse, rLhs);
114420 VdbeCoverage(v);
114421 addrTruthOp = sqlite3VdbeAddOp0(v, OP_Goto); /* Return True */
114423 sqlite3VdbeAddOp4(v, OP_Affinity, rLhs, nVector, 0, zAff, nVector);
114427 const VdbeOp *pOp = sqlite3VdbeGetOp(v, pExpr->y.sub.iAddr);
114431 sqlite3VdbeAddOp4Int(v, OP_Filter, pOp->p3, destIfFalse,
114432 rLhs, nVector); VdbeCoverage(v);
114435 sqlite3VdbeAddOp4Int(v, OP_NotFound, iTab, destIfFalse,
114436 rLhs, nVector); VdbeCoverage(v);
114440 addrTruthOp = sqlite3VdbeAddOp4Int(v, OP_Found, iTab, 0,
114441 rLhs, nVector); VdbeCoverage(v);
114448 sqlite3VdbeAddOp2(v, OP_NotNull, rRhsHasNull, destIfFalse);
114449 VdbeCoverage(v);
114455 if( destIfFalse==destIfNull ) sqlite3VdbeGoto(v, destIfFalse);
114464 if( destStep6 ) sqlite3VdbeResolveLabel(v, destStep6);
114465 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, destIfFalse);
114466 VdbeCoverage(v);
114480 sqlite3VdbeAddOp3(v, OP_Column, iTab, i, r3);
114481 sqlite3VdbeAddOp4(v, OP_Ne, rLhs+i, destNotNull, r3,
114483 VdbeCoverage(v);
114486 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfNull);
114488 sqlite3VdbeResolveLabel(v, destNotNull);
114489 sqlite3VdbeAddOp2(v, OP_Next, iTab, addrTop+1);
114490 VdbeCoverage(v);
114494 sqlite3VdbeAddOp2(v, OP_Goto, 0, destIfFalse);
114498 sqlite3VdbeJumpHere(v, addrTruthOp);
114502 VdbeComment((v, "end IN expr"));
114518 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
114524 sqlite3VdbeAddOp4Dup8(v, OP_Real, 0, iMem, 0, (u8*)&value, P4_REAL);
114537 Vdbe *v = pParse->pVdbe;
114542 sqlite3VdbeAddOp2(v, OP_Integer, i, iMem);
114560 codeReal(v, z, negFlag, iMem);
114565 sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, iMem, 0, (u8*)&value, P4_INT64);
114606 Vdbe *v = pParse->pVdbe;
114608 assert( v!=0 );
114611 iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
114617 sqlite3VdbeAddOp4(v, OP_Affinity, regOut, 1, 0, &pCol->affinity, 1);
114619 if( iAddr ) sqlite3VdbeJumpHere(v, iAddr);
114628 Vdbe *v, /* Parsing context */
114635 assert( v!=0 );
114639 sqlite3VdbeAddOp2(v, OP_Rowid, iTabCur, regOut);
114640 VdbeComment((v, "%s.rowid", pTab->zName));
114649 Parse *pParse = sqlite3VdbeParser(v);
114672 sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut);
114673 sqlite3ColumnDefault(v, pTab, iCol, regOut);
114770 static void setDoNotMergeFlagOnCopy(Vdbe *v){
114771 if( sqlite3VdbeGetLastOp(v)->opcode==OP_Copy ){
114772 sqlite3VdbeChangeP5(v, 1); /* Tag trailing OP_Copy as not mergeable */
114787 Vdbe *v = pParse->pVdbe;
114788 assert( v!=0 );
114803 sqlite3VdbeAddOp2(v, OP_NotNull, target, endCoalesce);
114804 VdbeCoverage(v);
114807 setDoNotMergeFlagOnCopy(v);
114808 sqlite3VdbeResolveLabel(v, endCoalesce);
114822 sqlite3VdbeAddOp3(v, OP_Offset, pArg->iTable, pArg->iColumn, target);
114824 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
114846 sqlite3VdbeAddOp2(v, OP_Integer,
114855 sqlite3VdbeAddOp2(v, OP_Integer,
114867 sqlite3VdbeAddOp2(v, OP_Integer,
114871 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
114888 sqlite3VdbeLoadString(v, target,
114962 Vdbe *v;
114993 v = pParse->pVdbe;
114994 assert( v!=0 );
114999 int addr = sqlite3VdbeCurrentAddr(v);
115000 sqlite3VdbeAddOp3(v, OP_IfNullRow, p->iIdxCur, addr+3, target);
115001 VdbeCoverage(v);
115002 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
115003 VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));
115004 sqlite3VdbeGoto(v, 0);
115009 sqlite3VdbeJumpHere(v, addr+2);
115011 sqlite3VdbeAddOp3(v, OP_Column, p->iIdxCur, p->iIdxCol, target);
115012 VdbeComment((v, "%s expr-column %d", p->zIdxName, p->iIdxCol));
115034 Vdbe *v = pParse->pVdbe;
115039 addr = sqlite3VdbeAddOp1(v, OP_IfNullRow, p->iIdxCur);
115045 sqlite3VdbeJumpHere(v, addr);
115046 sqlite3VdbeChangeP3(v, addr, ret);
115067 Vdbe *v = pParse->pVdbe; /* The VM under construction */
115077 assert( v!=0 );
115101 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
115105 sqlite3VdbeAddOp3(v, OP_NotNull, target, 1, 20230325);
115106 VdbeCoverageNeverTaken(v);
115115 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
115120 VdbeComment((v,"%s.rowid",pTab->zName));
115122 VdbeComment((v,"%s.%s",
115125 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
115132 sqlite3VdbeAddOp3(v, OP_Column, pExpr->iTable, pExpr->iColumn, target);
115157 sqlite3VdbeAddOp4(v, OP_Affinity, iReg, 1, 0,
115201 sqlite3VdbeAddOp2(v, OP_SCopy, iSrc, target);
115202 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
115230 sqlite3VdbeAddOp2(v, OP_Integer, sqlite3ExprTruthValue(pExpr), target);
115236 codeReal(v, pExpr->u.zToken, 0, target);
115242 sqlite3VdbeLoadString(v, target, pExpr->u.zToken);
115251 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
115265 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
115266 sqlite3VdbeAddOp4(v, OP_Blob, n/2, target, 0, zBlob, P4_DYNAMIC);
115274 sqlite3VdbeAddOp2(v, OP_Variable, pExpr->iColumn, target);
115286 sqlite3VdbeAddOp2(v, OP_Cast, target,
115308 sqlite3VdbeAddOp2(v, OP_Integer, 1, inReg);
115310 sqlite3VdbeCurrentAddr(v)+2, p5,
115312 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
115313 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
115314 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
115315 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
115316 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
115317 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
115319 sqlite3VdbeAddOp2(v, OP_Integer, 0, inReg);
115321 sqlite3VdbeAddOp3(v, OP_ZeroOrNull, r1, inReg, r2);
115353 sqlite3VdbeAddOp3(v, op, r2, r1, target);
115367 codeReal(v, pLeft->u.zToken, 1, target);
115377 sqlite3VdbeAddOp3(v, OP_Subtract, r2, r1, target);
115388 sqlite3VdbeAddOp2(v, op, r1, inReg);
115400 sqlite3VdbeAddOp4Int(v, OP_IsTrue, r1, inReg, !isTrue, isTrue ^ bNormal);
115408 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
115411 addr = sqlite3VdbeAddOp1(v, op, r1);
115412 VdbeCoverageIf(v, op==TK_ISNULL);
115413 VdbeCoverageIf(v, op==TK_NOTNULL);
115414 sqlite3VdbeAddOp2(v, OP_Integer, 0, target);
115415 sqlite3VdbeJumpHere(v, addr);
115544 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
115593 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
115595 sqlite3VdbeAddOp2(v, OP_Integer, 1, target);
115596 sqlite3VdbeResolveLabel(v, destIfFalse);
115597 sqlite3VdbeAddOp2(v, OP_AddImm, target, 0);
115598 sqlite3VdbeResolveLabel(v, destIfNull);
115629 sqlite3VdbeAddOp1(v, OP_ClrSubtype, target);
115683 sqlite3VdbeAddOp2(v, OP_Param, p1, target);
115684 VdbeComment((v, "r[%d]=%s.%s", target,
115696 sqlite3VdbeAddOp1(v, OP_RealAffinity, target);
115724 sqlite3VdbeAddOp3(v, OP_Column, pAggInfo->sortingIdxPTab,
115731 addrINR = sqlite3VdbeAddOp3(v, OP_IfNullRow, pExpr->iTable, 0, target);
115743 sqlite3VdbeJumpHere(v, addrINR);
115818 sqlite3VdbeGoto(v, endLabel);
115819 sqlite3VdbeResolveLabel(v, nextCase);
115824 sqlite3VdbeAddOp2(v, OP_Null, 0, target);
115827 setDoNotMergeFlagOnCopy(v);
115828 sqlite3VdbeResolveLabel(v, endLabel);
115848 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, OE_Ignore);
115849 VdbeCoverage(v);
115852 sqlite3VdbeAddOp3(v, OP_Halt,
115904 Vdbe *v = pParse->pVdbe;
115906 assert( v );
115907 addr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
115915 sqlite3VdbeJumpHere(v, addr);
116049 Vdbe *v = pParse->pVdbe;
116068 sqlite3VdbeAddOp2(v, copyOp, j+srcReg-1, target+i);
116079 && (pOp=sqlite3VdbeGetLastOp(v))->opcode==OP_Copy
116086 sqlite3VdbeAddOp2(v, copyOp, inReg, target+i);
116187 Vdbe *v = pParse->pVdbe;
116194 if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */
116210 sqlite3VdbeResolveLabel(v, d2);
116259 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
116260 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
116261 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
116262 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
116264 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ);
116265 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ);
116267 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ);
116268 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ);
116279 if( regFree1 ) sqlite3VdbeTypeofColumn(v, r1);
116280 sqlite3VdbeAddOp2(v, op, r1, dest);
116281 VdbeCoverageIf(v, op==TK_ISNULL);
116282 VdbeCoverageIf(v, op==TK_NOTNULL);
116295 sqlite3VdbeGoto(v, dest);
116296 sqlite3VdbeResolveLabel(v, destIfFalse);
116303 sqlite3VdbeGoto(v, dest);
116308 sqlite3VdbeAddOp3(v, OP_If, r1, dest, jumpIfNull!=0);
116309 VdbeCoverage(v);
116330 Vdbe *v = pParse->pVdbe;
116337 if( NEVER(v==0) ) return; /* Existence of VDBE checked by caller */
116388 sqlite3VdbeResolveLabel(v, d2);
116436 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
116437 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
116438 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
116439 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
116441 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull!=SQLITE_NULLEQ);
116442 VdbeCoverageIf(v, op==OP_Eq && jumpIfNull==SQLITE_NULLEQ);
116444 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull!=SQLITE_NULLEQ);
116445 VdbeCoverageIf(v, op==OP_Ne && jumpIfNull==SQLITE_NULLEQ);
116454 if( regFree1 ) sqlite3VdbeTypeofColumn(v, r1);
116455 sqlite3VdbeAddOp2(v, op, r1, dest);
116456 testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL);
116457 testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL);
116472 sqlite3VdbeResolveLabel(v, destIfNull);
116480 sqlite3VdbeGoto(v, dest);
116485 sqlite3VdbeAddOp3(v, OP_IfNot, r1, dest, jumpIfNull!=0);
116486 VdbeCoverage(v);
116795 int v;
116798 v = 1;
116799 if( sqlite3ExprIsInteger(pExpr, &v, 0) && v==0 ) return 1;
117854 Vdbe *v = pParse->pVdbe;
117855 if( v ){
117878 Vdbe *v;
117879 VTable *pVTab = 0; /* Non-zero if this is a v-tab with an xRename() */
117946 v = sqlite3GetVdbe(pParse);
117947 if( v==0 ){
118012 ** of any resources used by the v-table implementation (including other
118018 sqlite3VdbeLoadString(v, i, zName);
118019 sqlite3VdbeAddOp4(v, OP_VRename, i, 0, 0,(const char*)pVTab, P4_VTAB);
118065 Vdbe *v; /* The prepared statement under construction */
118170 v = sqlite3GetVdbe(pParse);
118171 if( v ){
118177 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
118178 sqlite3VdbeUsesBtree(v, iDb);
118179 sqlite3VdbeAddOp2(v, OP_AddImm, r1, -2);
118180 sqlite3VdbeAddOp2(v, OP_IfPos, r1, sqlite3VdbeCurrentAddr(v)+2);
118181 VdbeCoverage(v);
118182 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 3);
119994 Vdbe *v = sqlite3GetVdbe(pParse);
119997 addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
120000 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg);
120006 sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1);
120023 sqlite3VdbeAddOp2(v, OP_Null, 0, regOut);
120029 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
120038 sqlite3VdbeAddOp2(v, OP_Null, 0, reg+1);
120041 sqlite3VdbeAddOp3(v, OP_MakeRecord, reg+1, nField, regRec);
120043 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol);
120045 sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg);
120047 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
120049 sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v);
120050 sqlite3VdbeJumpHere(v, addr);
120262 Vdbe *v = sqlite3GetVdbe(pParse);
120271 if( v==0 ) return;
120273 assert( sqlite3VdbeDb(v)==db );
120313 sqlite3VdbeAddOp2(v, OP_Clear, (int)aRoot[i], iDb);
120321 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, iStatCur+i, (int)aRoot[i], iDb, 3);
120322 sqlite3VdbeChangeP5(v, aCreateTbl[i]);
120323 VdbeComment((v, aTable[i].zName));
121027 Vdbe *v, /* Prepared statement under construction */
121035 VdbeComment((v,"%s.rowid",pIdx->zName));
121038 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
121040 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
121063 Vdbe *v; /* The virtual machine being built up */
121087 v = sqlite3GetVdbe(pParse);
121088 if( v==0 || NEVER(pTab==0) ){
121131 sqlite3VdbeLoadString(v, regTabname, pTab->zName);
121153 sqlite3VdbeLoadString(v, regIdxname, zIdxName);
121154 VdbeComment((v, "Analysis for %s.%s", pTab->zName, zIdxName));
121201 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
121203 VdbeComment((v, "%s", pIdx->zName));
121218 sqlite3VdbeAddOp2(v, OP_Integer, db->nAnalysisLimit, regTemp2);
121225 sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat+1);
121227 sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid);
121228 sqlite3VdbeAddOp3(v, OP_Count, iIdxCur, regTemp,
121232 addrGotoEnd = sqlite3VdbeAddOp1(v, OP_Rewind, iIdxCur);
121233 VdbeCoverage(v);
121235 sqlite3VdbeAddOp2(v, OP_Integer, 0, regChng);
121236 addrNextRow = sqlite3VdbeCurrentAddr(v);
121254 sqlite3VdbeAddOp0(v, OP_Goto);
121255 addrNextRow = sqlite3VdbeCurrentAddr(v);
121260 sqlite3VdbeAddOp2(v, OP_NotNull, regPrev, endDistinctTest);
121261 VdbeCoverage(v);
121265 sqlite3VdbeAddOp2(v, OP_Integer, i, regChng);
121266 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regTemp);
121267 analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
121269 sqlite3VdbeAddOp4(v, OP_Ne, regTemp, 0, regPrev+i, pColl, P4_COLLSEQ);
121270 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
121271 VdbeCoverage(v);
121273 sqlite3VdbeAddOp2(v, OP_Integer, nColTest, regChng);
121274 sqlite3VdbeGoto(v, endDistinctTest);
121284 sqlite3VdbeJumpHere(v, addrNextRow-1);
121286 sqlite3VdbeJumpHere(v, aGotoChng[i]);
121287 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, i, regPrev+i);
121288 analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
121290 sqlite3VdbeResolveLabel(v, endDistinctTest);
121305 sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, regRowid);
121313 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, regKey+j);
121314 analyzeVdbeCommentIndexWithColumnName(v,pIdx,k);
121316 sqlite3VdbeAddOp3(v, OP_MakeRecord, regKey, pPk->nKeyCol, regRowid);
121327 j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regTemp); VdbeCoverage(v);
121328 j2 = sqlite3VdbeAddOp1(v, OP_If, regTemp); VdbeCoverage(v);
121329 j3 = sqlite3VdbeAddOp4Int(v, OP_SeekGT, iIdxCur, 0, regPrev, 1);
121330 VdbeCoverage(v);
121331 sqlite3VdbeJumpHere(v, j1);
121332 sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
121333 sqlite3VdbeJumpHere(v, j2);
121334 sqlite3VdbeJumpHere(v, j3);
121336 sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
121344 sqlite3VdbeJumpHere(v, addrGotoEnd);
121349 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
121350 sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
121351 sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
121353 sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
121355 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
121372 sqlite3VdbeAddOp2(v, OP_Cast, regStat1, SQLITE_AFF_INTEGER);
121373 addrGotoEnd = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1);
121374 VdbeCoverage(v);
121407 addrNext = sqlite3VdbeCurrentAddr(v);
121409 addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regSampleRowid);
121410 VdbeCoverage(v);
121414 sqlite3VdbeAddOp4Int(v, seekOp, iTabCur, addrNext, regSampleRowid, 0);
121415 VdbeCoverage(v);
121419 sqlite3VdbeAddOp3(v, OP_MakeRecord, regCol, nCol, regSample);
121420 sqlite3VdbeAddOp3(v, OP_MakeRecord, regTabname, 6, regTemp);
121421 sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur+1, regNewRowid);
121422 sqlite3VdbeAddOp3(v, OP_Insert, iStatCur+1, regTemp, regNewRowid);
121423 sqlite3VdbeAddOp2(v, OP_Goto, 1, addrNext); /* P1==1 for end-of-loop */
121424 sqlite3VdbeJumpHere(v, addrIsNull);
121429 if( addrGotoEnd ) sqlite3VdbeJumpHere(v, addrGotoEnd);
121437 VdbeComment((v, "%s", pTab->zName));
121438 sqlite3VdbeAddOp2(v, OP_Count, iTabCur, regStat1);
121439 jZeroRows = sqlite3VdbeAddOp1(v, OP_IfNot, regStat1); VdbeCoverage(v);
121440 sqlite3VdbeAddOp2(v, OP_Null, 0, regIdxname);
121442 sqlite3VdbeAddOp4(v, OP_MakeRecord, regTabname, 3, regTemp, "BBB", 0);
121443 sqlite3VdbeAddOp2(v, OP_NewRowid, iStatCur, regNewRowid);
121444 sqlite3VdbeAddOp3(v, OP_Insert, iStatCur, regTemp, regNewRowid);
121445 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
121447 sqlite3VdbeChangeP4(v, -1, (char*)pStat1, P4_TABLE);
121449 sqlite3VdbeJumpHere(v, jZeroRows);
121459 Vdbe *v = sqlite3GetVdbe(pParse);
121460 if( v ){
121461 sqlite3VdbeAddOp1(v, OP_LoadAnalysis, iDb);
121539 Vdbe *v;
121574 if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
121575 sqlite3VdbeAddOp0(v, OP_Expire);
121604 tRowcnt v;
121612 v = 0;
121614 v = v*10 + c - '0';
121618 if( aOut ) aOut[i] = v;
121619 if( aLog ) aLog[i] = sqlite3LogEst(v);
121624 aLog[i] = sqlite3LogEst(v);
122446 Vdbe *v;
122481 v = sqlite3GetVdbe(pParse);
122487 assert( v || db->mallocFailed );
122488 if( v ){
122495 sqlite3VdbeAddOp1(v, OP_Expire, (type==SQLITE_ATTACH));
123120 Vdbe *v;
123136 v = pParse->pVdbe;
123137 if( v==0 ){
123142 v = sqlite3GetVdbe(pParse);
123143 if( v==0 ) pParse->rc = SQLITE_ERROR;
123146 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
123147 if( v ){
123156 sqlite3VdbeAddOp0(v, OP_FkCheck);
123158 sqlite3VdbeAddOp1(v, OP_Rewind, pReturning->iRetCur);
123159 VdbeCoverage(v);
123162 sqlite3VdbeAddOp3(v, OP_Column, pReturning->iRetCur, i, reg+i);
123164 sqlite3VdbeAddOp2(v, OP_ResultRow, reg, i);
123165 sqlite3VdbeAddOp2(v, OP_Next, pReturning->iRetCur, addrRewind+1);
123166 VdbeCoverage(v);
123167 sqlite3VdbeJumpHere(v, addrRewind);
123170 sqlite3VdbeAddOp0(v, OP_Halt);
123178 assert( pParse->nErr>0 || sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
123179 sqlite3VdbeJumpHere(v, 0);
123185 sqlite3VdbeUsesBtree(v, iDb);
123187 sqlite3VdbeAddOp4Int(v,
123194 if( db->init.busy==0 ) sqlite3VdbeChangeP5(v, 1);
123195 VdbeComment((v,
123201 sqlite3VdbeAddOp4(v, OP_VBegin, 0, 0, 0, vtab, P4_VTAB);
123234 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRet->iRetCur, pRet->nRetCol);
123239 sqlite3VdbeGoto(v, 1);
123244 assert( v!=0 || pParse->nErr );
123250 sqlite3VdbeMakeReady(v, pParse);
123883 Vdbe *v = sqlite3GetVdbe(p);
123885 sqlite3VdbeAddOp4Int(v, OP_OpenWrite, 0, SCHEMA_ROOT, iDb, 5);
124103 ** V means VIRTUAL. Suppose the CREATE TABLE has columns like this:
124105 ** CREATE TABLE ex(N,S,V,N,S,V,N,S,V);
124149 Vdbe *v = sqlite3GetVdbe(pParse);
124150 if( v ){
124151 sqlite3VdbeAddOp3(v, OP_JournalMode, 0, iReg, PAGER_JOURNALMODE_QUERY);
124152 sqlite3VdbeUsesBtree(v, 0);
124184 Vdbe *v;
124293 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
124303 sqlite3VdbeAddOp0(v, OP_VBegin);
124314 sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, reg3, BTREE_FILE_FORMAT);
124315 sqlite3VdbeUsesBtree(v, iDb);
124316 addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
124319 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
124320 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
124321 sqlite3VdbeJumpHere(v, addr1);
124334 sqlite3VdbeAddOp2(v, OP_Integer, 0, reg2);
124340 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, reg2, BTREE_INTKEY);
124343 sqlite3VdbeAddOp2(v, OP_NewRowid, 0, reg1);
124344 sqlite3VdbeAddOp4(v, OP_Blob, 6, reg3, 0, nullRow, P4_STATIC);
124345 sqlite3VdbeAddOp3(v, OP_Insert, 0, reg3, reg1);
124346 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
124347 sqlite3VdbeAddOp0(v, OP_Close);
124655 int v = 0; /* default size is approx 4 bytes */
124661 sqlite3GetInt32(zChar, &v);
124667 v = 16; /* BLOB, TEXT, CLOB -> r=5 (approx 20 bytes)*/
124671 if( v>=sqlite3GlobalConfig.szSorterRef ){
124675 v = v/4 + 1;
124676 if( v>255 ) v = 255;
124677 pCol->szEst = v;
125012 Vdbe *v = pParse->pVdbe;
125014 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION,
125324 Vdbe *v = pParse->pVdbe;
125344 assert( v );
125345 sqlite3VdbeChangeP3(v, pParse->u1.cr.addrCrTab, BTREE_BLOBKEY);
125406 if( v && pPk->tnum>0 ){
125408 sqlite3VdbeChangeOpcode(v, (int)pPk->tnum, OP_Goto);
125758 Vdbe *v;
125763 v = sqlite3GetVdbe(pParse);
125764 if( NEVER(v==0) ) return;
125766 sqlite3VdbeAddOp1(v, OP_Close, 0);
125817 sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->u1.cr.regRoot, iDb);
125818 sqlite3VdbeChangeP5(v, OPFLAG_P2ISREG);
125819 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
125820 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
125833 sqlite3VdbeEndCoroutine(v, regYield);
125834 sqlite3VdbeJumpHere(v, addrTop - 1);
125835 addrInsLoop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
125836 VdbeCoverage(v);
125837 sqlite3VdbeAddOp3(v, OP_MakeRecord, dest.iSdst, dest.nSdst, regRec);
125838 sqlite3TableAffinity(v, p, 0);
125839 sqlite3VdbeAddOp2(v, OP_NewRowid, iCsr, regRowid);
125840 sqlite3VdbeAddOp3(v, OP_Insert, iCsr, regRec, regRowid);
125841 sqlite3VdbeGoto(v, addrInsLoop);
125842 sqlite3VdbeJumpHere(v, addrInsLoop);
125843 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
125895 sqlite3VdbeAddParseSchemaOp(v, iDb,
125901 sqlite3VdbeAddOp4(v, OP_SqlExec, 0x0001, 0, 0,
126245 Vdbe *v = sqlite3GetVdbe(pParse);
126248 sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
126347 Vdbe *v;
126352 v = sqlite3GetVdbe(pParse);
126353 assert( v!=0 );
126358 sqlite3VdbeAddOp0(v, OP_VBegin);
126407 sqlite3VdbeAddOp4(v, OP_VDestroy, iDb, 0, 0, pTab->zName, 0);
126410 sqlite3VdbeAddOp4(v, OP_DropTable, iDb, 0, 0, pTab->zName, 0);
126456 Vdbe *v;
126546 v = sqlite3GetVdbe(pParse);
126547 if( v ){
126740 Vdbe *v; /* Generate code into this virtual machine */
126756 v = sqlite3GetVdbe(pParse);
126757 if( v==0 ) return;
126768 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, pIndex->nKeyCol, (char*)
126774 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
126779 sqlite3VdbeAddOp2(v, OP_SorterInsert, iSorter, regRecord);
126781 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
126782 sqlite3VdbeJumpHere(v, addr1);
126783 if( memRootPage<0 ) sqlite3VdbeAddOp2(v, OP_Clear, tnum, iDb);
126784 sqlite3VdbeAddOp4(v, OP_OpenWrite, iIdx, (int)tnum, iDb,
126786 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR|((memRootPage>=0)?OPFLAG_P2ISREG:0));
126788 addr1 = sqlite3VdbeAddOp2(v, OP_SorterSort, iSorter, 0); VdbeCoverage(v);
126790 int j2 = sqlite3VdbeGoto(v, 1);
126791 addr2 = sqlite3VdbeCurrentAddr(v);
126792 sqlite3VdbeVerifyAbortable(v, OE_Abort);
126793 sqlite3VdbeAddOp4Int(v, OP_SorterCompare, iSorter, j2, regRecord,
126794 pIndex->nKeyCol); VdbeCoverage(v);
126796 sqlite3VdbeJumpHere(v, j2);
126806 addr2 = sqlite3VdbeCurrentAddr(v);
126808 sqlite3VdbeAddOp3(v, OP_SorterData, iSorter, regRecord, iIdx);
126817 sqlite3VdbeAddOp1(v, OP_SeekEnd, iIdx);
126819 sqlite3VdbeAddOp2(v, OP_IdxInsert, iIdx, regRecord);
126820 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
126822 sqlite3VdbeAddOp2(v, OP_SorterNext, iSorter, addr2); VdbeCoverage(v);
126823 sqlite3VdbeJumpHere(v, addr1);
126825 sqlite3VdbeAddOp1(v, OP_Close, iTab);
126826 sqlite3VdbeAddOp1(v, OP_Close, iIdx);
126827 sqlite3VdbeAddOp1(v, OP_Close, iSorter);
127384 Vdbe *v;
127388 v = sqlite3GetVdbe(pParse);
127389 if( v==0 ) goto exit_create_index;
127399 pIndex->tnum = (Pgno)sqlite3VdbeAddOp0(v, OP_Noop);
127400 sqlite3VdbeAddOp3(v, OP_CreateBtree, iDb, iMem, BTREE_BLOBKEY);
127436 sqlite3VdbeAddParseSchemaOp(v, iDb,
127438 sqlite3VdbeAddOp2(v, OP_Expire, 0, 1);
127441 sqlite3VdbeJumpHere(v, (int)pIndex->tnum);
127557 Vdbe *v;
127605 v = sqlite3GetVdbe(pParse);
127606 if( v ){
127615 sqlite3VdbeAddOp4(v, OP_DropIndex, iDb, 0, 0, pIndex->zName, 0);
128200 Vdbe *v;
128209 v = sqlite3GetVdbe(pParse);
128210 if( !v ) return;
128222 sqlite3VdbeAddOp2(v, OP_Transaction, i, eTxnType);
128223 sqlite3VdbeUsesBtree(v, i);
128226 sqlite3VdbeAddOp0(v, OP_AutoCommit);
128235 Vdbe *v;
128246 v = sqlite3GetVdbe(pParse);
128247 if( v ){
128248 sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, isRollback);
128259 Vdbe *v = sqlite3GetVdbe(pParse);
128264 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
128268 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
128409 Vdbe *v;
128411 v = sqlite3GetVdbe(pParse);
128416 sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
128417 sqlite3VdbeChangeP5(v, p5Errmsg);
129372 SQLITE_PRIVATE void sqlite3CodeChangeCount(Vdbe *v, int regCounter, const char *zColName){
129373 sqlite3VdbeAddOp0(v, OP_FkCheck);
129374 sqlite3VdbeAddOp2(v, OP_ResultRow, regCounter, 1);
129375 sqlite3VdbeSetNumCols(v, 1);
129376 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zColName, SQLITE_STATIC);
129616 Vdbe *v; /* The virtual database engine */
129738 v = sqlite3GetVdbe(pParse);
129739 if( v==0 ){
129742 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
129777 sqlite3VdbeAddOp2(v, OP_Integer, 0, memCnt);
129803 sqlite3VdbeAddOp4(v, OP_Clear, pTab->tnum, iDb, memCnt ? memCnt : -1,
129809 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
129811 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
129825 sqlite3VdbeAddOp2(v, OP_Null, 0, iRowSet);
129835 addrEphOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEphCur, nPk);
129855 sqlite3VdbeAddOp1(v, OP_FinishSeek, iTabCur);
129860 sqlite3VdbeAddOp2(v, OP_AddImm, memCnt, 1);
129867 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur,
129873 sqlite3ExprCodeGetColumnOfTable(v, pTab, iTabCur, -1, iKey);
129890 if( addrEphOpen ) sqlite3VdbeChangeToNoop(v, addrEphOpen);
129897 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, iKey,
129899 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEphCur, iKey, iPk, nPk);
129903 sqlite3VdbeAddOp2(v, OP_RowSetAdd, iRowSet, iKey);
129916 iAddrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
129924 sqlite3VdbeJumpHereOrPopInst(v, iAddrOnce);
129935 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, addrBypass, iKey, nKey);
129936 VdbeCoverage(v);
129939 addrLoop = sqlite3VdbeAddOp1(v, OP_Rewind, iEphCur); VdbeCoverage(v);
129941 sqlite3VdbeAddOp3(v, OP_Column, iEphCur, 0, iKey);
129943 sqlite3VdbeAddOp2(v, OP_RowData, iEphCur, iKey);
129947 addrLoop = sqlite3VdbeAddOp3(v, OP_RowSetRead, iRowSet, 0, iKey);
129948 VdbeCoverage(v);
129960 sqlite3VdbeAddOp1(v, OP_Close, iTabCur);
129965 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iKey, pVTab, P4_VTAB);
129966 sqlite3VdbeChangeP5(v, OE_Abort);
129977 sqlite3VdbeResolveLabel(v, addrBypass);
129980 sqlite3VdbeAddOp2(v, OP_Next, iEphCur, addrLoop+1); VdbeCoverage(v);
129981 sqlite3VdbeJumpHere(v, addrLoop);
129983 sqlite3VdbeGoto(v, addrLoop);
129984 sqlite3VdbeJumpHere(v, addrLoop);
130001 sqlite3CodeChangeCount(v, memCnt, "rows deleted");
130079 Vdbe *v = pParse->pVdbe; /* Vdbe */
130085 assert( v );
130086 VdbeModuleComment((v, "BEGIN: GenRowDel(%d,%d,%d,%d)",
130095 sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
130096 VdbeCoverageIf(v, opSeek==OP_NotExists);
130097 VdbeCoverageIf(v, opSeek==OP_NotFound);
130118 sqlite3VdbeAddOp2(v, OP_Copy, iPk, iOld);
130124 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, iCol, iOld+kk+1);
130129 addrStart = sqlite3VdbeCurrentAddr(v);
130142 if( addrStart<sqlite3VdbeCurrentAddr(v) ){
130143 sqlite3VdbeAddOp4Int(v, opSeek, iDataCur, iLabel, iPk, nPk);
130144 VdbeCoverageIf(v, opSeek==OP_NotExists);
130145 VdbeCoverageIf(v, opSeek==OP_NotFound);
130169 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
130171 sqlite3VdbeAppendP4(v, (char*)pTab, P4_TABLE);
130174 sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);
130177 sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);
130180 sqlite3VdbeChangeP5(v, p5);
130198 sqlite3VdbeResolveLabel(v, iLabel);
130199 VdbeModuleComment((v, "END: GenRowDel()"));
130233 Vdbe *v; /* The prepared statement under construction */
130236 v = pParse->pVdbe;
130243 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
130246 sqlite3VdbeAddOp3(v, OP_IdxDelete, iIdxCur+i, r1,
130248 sqlite3VdbeChangeP5(v, 1); /* Cause IdxDelete to error if no entry found */
130295 Vdbe *v = pParse->pVdbe;
130332 sqlite3VdbeDeletePriorOpcode(v, OP_RealAffinity);
130336 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regOut);
130447 /* EVIDENCE-OF: R-01470-60482 The sqlite3_value_type(V) interface returns
130449 ** V. The returned value is one of SQLITE_INTEGER, SQLITE_FLOAT,
131513 int v = 0;
131516 v = (v<<4) + sqlite3HexToInt(z[i]);
131518 *pVal = v;
131544 u32 v;
131575 if( !isNHex(&zIn[i+1], 4, &v) ) goto unistr_error;
131577 j += sqlite3AppendOneUtf8Character(&zOut[j], v);
131579 if( !isNHex(&zIn[i+2], 6, &v) ) goto unistr_error;
131581 j += sqlite3AppendOneUtf8Character(&zOut[j], v);
131583 if( !isNHex(&zIn[i+2], 4, &v) ) goto unistr_error;
131585 j += sqlite3AppendOneUtf8Character(&zOut[j], v);
131587 if( !isNHex(&zIn[i+2], 8, &v) ) goto unistr_error;
131589 j += sqlite3AppendOneUtf8Character(&zOut[j], v);
132040 const char *v = (const char*)sqlite3_value_text(argv[i]);
132041 if( v!=0 ){
132046 memcpy(&z[j], v, k);
133634 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
133638 sqlite3VdbeVerifyAbortable(v,
133652 sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, iOk);
133653 VdbeCoverage(v);
133657 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iOk); VdbeCoverage(v);
133672 sqlite3VdbeAddOp2(v, OP_SCopy,
133674 iMustBeInt = sqlite3VdbeAddOp2(v, OP_MustBeInt, regTemp, 0);
133675 VdbeCoverage(v);
133682 sqlite3VdbeAddOp3(v, OP_Eq, regData, iOk, regTemp); VdbeCoverage(v);
133683 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
133687 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v);
133688 sqlite3VdbeGoto(v, iOk);
133689 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
133690 sqlite3VdbeJumpHere(v, iMustBeInt);
133696 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
133699 sqlite3VdbeAddOp2(v, OP_Copy,
133715 int iJump = sqlite3VdbeCurrentAddr(v) + nCol + 1;
133728 sqlite3VdbeAddOp3(v, OP_Ne, iChild, iJump, iParent); VdbeCoverage(v);
133729 sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
133731 sqlite3VdbeGoto(v, iOk);
133734 sqlite3VdbeAddOp4(v, OP_Affinity, regTemp, nCol, 0,
133736 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);
133737 VdbeCoverage(v);
133757 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
133760 sqlite3VdbeResolveLabel(v, iOk);
133761 sqlite3VdbeAddOp1(v, OP_Close, iCur);
133865 Vdbe *v = sqlite3GetVdbe(pParse);
133873 iFkIfZero = sqlite3VdbeAddOp2(v, OP_FkIfZero, pFKey->isDeferred, 0);
133874 VdbeCoverage(v);
133951 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, nIncr);
133960 sqlite3VdbeJumpHereOrPopInst(v, iFkIfZero);
134041 Vdbe *v = sqlite3GetVdbe(pParse);
134043 assert( v ); /* VDBE has already been allocated */
134057 sqlite3VdbeAddOp2(v, OP_FkIfZero, 1, iSkip); VdbeCoverage(v);
134074 sqlite3VdbeVerifyAbortable(v, OE_Abort);
134075 sqlite3VdbeAddOp2(v, OP_FkIfZero, 0, sqlite3VdbeCurrentAddr(v)+2);
134076 VdbeCoverage(v);
134082 sqlite3VdbeResolveLabel(v, iSkip);
134252 Vdbe *v = sqlite3GetVdbe(pParse);
134253 int iJump = sqlite3VdbeCurrentAddr(v) + pFKey->nCol + 1;
134258 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, iJump); VdbeCoverage(v);
134260 sqlite3VdbeAddOp2(v, OP_FkCounter, pFKey->isDeferred, -1);
134822 Vdbe *v;
134825 v = pParse->pVdbe;
134832 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
134833 VdbeComment((v, "%s", pTab->zName));
134838 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
134840 VdbeComment((v, "%s", pTab->zName));
134968 SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
134977 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
134978 pPrev = sqlite3VdbeGetLastOp(v);
134980 assert( pPrev->opcode==OP_MakeRecord || sqlite3VdbeDb(v)->mallocFailed );
134982 sqlite3VdbeAddOp3(v, OP_MakeRecord, pPrev->p1, pPrev->p2, pPrev->p3);
134985 sqlite3VdbeAddOp2(v, OP_TypeCheck, iReg, pTab->nNVCol);
134986 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
134994 sqlite3OomFault(sqlite3VdbeDb(v));
135003 sqlite3VdbeAddOp4(v, OP_Affinity, iReg, i, 0, zColAff, i);
135005 assert( sqlite3VdbeGetLastOp(v)->opcode==OP_MakeRecord
135006 || sqlite3VdbeDb(v)->mallocFailed );
135007 sqlite3VdbeChangeP4(v, -1, zColAff, i);
135019 Vdbe *v = sqlite3GetVdbe(p);
135021 int iEnd = sqlite3VdbeCurrentAddr(v);
135027 VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
135251 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
135258 assert( v ); /* We failed long ago if this is not so */
135280 sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
135281 aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
135322 Vdbe *v = pParse->pVdbe;
135325 assert( v );
135342 sqlite3VdbeAddOp3(v, OP_Le, memId+2, sqlite3VdbeCurrentAddr(v)+7, memId);
135343 VdbeCoverage(v);
135345 aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
135498 Vdbe *v = sqlite3GetVdbe(pParse);
135525 pSubq->addrFillSub = sqlite3VdbeCurrentAddr(v) + 1;
135527 sqlite3VdbeAddOp3(v, OP_InitCoroutine,
135691 Vdbe *v; /* Generate code into this virtual machine */
135801 v = sqlite3GetVdbe(pParse);
135802 if( v==0 ) goto insert_cleanup;
135803 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
135928 addrTop = sqlite3VdbeCurrentAddr(v) + 1;
135929 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
135938 sqlite3VdbeEndCoroutine(v, regYield);
135939 sqlite3VdbeJumpHere(v, addrTop - 1); /* label B: */
135975 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
135976 addrL = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm); VdbeCoverage(v);
135977 sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
135978 sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
135979 sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
135980 sqlite3VdbeGoto(v, addrL);
135981 sqlite3VdbeJumpHere(v, addrL);
136055 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
136118 addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab); VdbeCoverage(v);
136119 addrCont = sqlite3VdbeCurrentAddr(v);
136130 addrInsTop = addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iSDParm);
136131 VdbeCoverage(v);
136136 sqlite3VdbeAddOp2(v, OP_Copy, regFromSelect+ipkColumn, regRowid);
136158 sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
136175 sqlite3VdbeAddOp1(v, OP_SoftNull, iRegStore);
136210 sqlite3VdbeAddOp3(v, OP_Column, srcTab, k, iRegStore);
136213 sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+k, iRegStore);
136219 sqlite3VdbeAddOp2(v,
136239 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
136244 sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regCols);
136249 addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols); VdbeCoverage(v);
136250 sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
136251 sqlite3VdbeJumpHere(v, addr1);
136252 sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols); VdbeCoverage(v);
136257 sqlite3VdbeAddOp3(v, OP_Copy, regRowid+1, regCols+1, pTab->nNVCol-1);
136277 sqlite3TableAffinity(v, pTab, regCols+1);
136290 sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
136295 sqlite3VdbeAddOp3(v, OP_Column, srcTab, ipkColumn, regRowid);
136301 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
136313 addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid); VdbeCoverage(v);
136314 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
136315 sqlite3VdbeJumpHere(v, addr1);
136317 addr1 = sqlite3VdbeCurrentAddr(v);
136318 sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, addr1+2); VdbeCoverage(v);
136320 sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid); VdbeCoverage(v);
136323 sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
136325 sqlite3VdbeAddOp3(v, OP_NewRowid, iDataCur, regRowid, regAutoinc);
136347 sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
136348 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
136370 bUseSeek = (isReplace==0 || !sqlite3VdbeHasSubProgram(v));
136380 sqlite3VdbeAddOp2(v, OP_Integer, -1, regRowid);
136387 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
136399 sqlite3VdbeResolveLabel(v, endOfLoop);
136401 sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont); VdbeCoverage(v);
136402 sqlite3VdbeJumpHere(v, addrInsTop);
136403 sqlite3VdbeAddOp1(v, OP_Close, srcTab);
136405 sqlite3VdbeGoto(v, addrCont);
136410 if( sqlite3VdbeGetOp(v, addrCont-1)->opcode==OP_ReleaseReg ){
136411 assert( sqlite3VdbeGetOp(v, addrCont)->opcode==OP_Yield );
136412 sqlite3VdbeChangeP5(v, 1);
136415 sqlite3VdbeJumpHere(v, addrInsTop);
136435 sqlite3CodeChangeCount(v, regRowCount, "rows inserted");
136696 Vdbe *v; /* VDBE under construction */
136724 v = pParse->pVdbe;
136725 assert( v!=0 );
136742 VdbeModuleComment((v, "BEGIN: GenCnstCks(%d,%d,%d,%d,%d)",
136795 int addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, iReg);
136796 VdbeCoverage(v);
136801 sqlite3VdbeJumpHere(v, addr1);
136812 sqlite3VdbeAddOp3(v, OP_HaltIfNull, SQLITE_CONSTRAINT_NOTNULL,
136814 sqlite3VdbeAppendP4(v, zMsg, P4_DYNAMIC);
136815 sqlite3VdbeChangeP5(v, P5_ConstraintNotNull);
136816 VdbeCoverage(v);
136821 sqlite3VdbeAddOp2(v, OP_IsNull, iReg, ignoreDest);
136822 VdbeCoverage(v);
136866 sqlite3TableAffinity(v, pTab, regNewData+1);
136870 sqlite3VdbeVerifyAbortable(v, onError);
136877 sqlite3VdbeGoto(v, ignoreDest);
136886 sqlite3VdbeResolveLabel(v, allOk);
137017 sqlite3VdbeAddOp2(v, OP_Integer, 0, regTrigCnt);
137018 VdbeComment((v, "trigger count"));
137052 upsertIpkDelay = sqlite3VdbeAddOp0(v, OP_Goto);
137066 ipkTop = sqlite3VdbeAddOp0(v, OP_Goto)+1;
137067 VdbeComment((v, "defer IPK REPLACE until last"));
137074 sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRowidOk, regOldData);
137075 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
137076 VdbeCoverage(v);
137081 VdbeNoopComment((v, "uniqueness check for ROWID"));
137082 sqlite3VdbeVerifyAbortable(v, onError);
137083 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRowidOk, regNewData);
137084 VdbeCoverage(v);
137127 sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
137136 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, OPFLAG_ISNOOP);
137137 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
137155 sqlite3VdbeGoto(v, ignoreDest);
137159 sqlite3VdbeResolveLabel(v, addrRowidOk);
137161 upsertIpkReturn = sqlite3VdbeAddOp0(v, OP_Goto);
137163 ipkBottom = sqlite3VdbeAddOp0(v, OP_Goto);
137164 sqlite3VdbeJumpHere(v, ipkTop-1);
137189 sqlite3VdbeJumpHere(v, upsertIpkDelay);
137194 sqlite3TableAffinity(v, pTab, regNewData+1);
137197 VdbeNoopComment((v, "prep index %s", pIdx->zName));
137203 sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[ix]);
137221 VdbeComment((v, "%s column %d", pIdx->zName, i));
137224 sqlite3VdbeAddOp2(v, OP_IntCopy, x, regIdx+i);
137225 VdbeComment((v, "rowid"));
137229 sqlite3VdbeAddOp2(v, OP_SCopy, x, regIdx+i);
137230 VdbeComment((v, "%s", pTab->aCol[iField].zCnName));
137233 sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
137234 VdbeComment((v, "for %s", pIdx->zName));
137237 sqlite3SetMakeRecordP5(v, pIdx->pTable);
137247 sqlite3VdbeResolveLabel(v, addrUniqueOk);
137254 sqlite3VdbeResolveLabel(v, addrUniqueOk);
137292 sqlite3VdbeResolveLabel(v, addrUniqueOk);
137298 sqlite3VdbeVerifyAbortable(v, onError);
137300 sqlite3VdbeAddOp4Int(v, OP_NoConflict, iThisCur, addrUniqueOk,
137301 regIdx, pIdx->nKeyCol); VdbeCoverage(v);
137307 sqlite3VdbeAddOp2(v, OP_IdxRowid, iThisCur, regR);
137311 sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldData);
137312 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
137313 VdbeCoverage(v);
137323 sqlite3VdbeAddOp3(v, OP_Column, iThisCur, x, regR+i);
137324 VdbeComment((v, "%s.%s", pTab->zName,
137336 int addrJump = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
137349 sqlite3VdbeAddOp4(v, op,
137352 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
137353 VdbeCoverageIf(v, op==OP_Eq);
137354 VdbeCoverageIf(v, op==OP_Ne);
137381 sqlite3VdbeGoto(v, ignoreDest);
137388 nConflictCk = sqlite3VdbeCurrentAddr(v) - addrConflictCk;
137397 sqlite3VdbeAddOp1(v, OP_CursorLock, iDataCur);
137403 sqlite3VdbeAddOp1(v, OP_CursorUnlock, iDataCur);
137408 sqlite3VdbeAddOp2(v, OP_AddImm, regTrigCnt, 1); /* incr trigger cnt */
137409 addrBypass = sqlite3VdbeAddOp0(v, OP_Goto); /* Bypass recheck */
137410 VdbeComment((v, "bypass recheck"));
137415 sqlite3VdbeResolveLabel(v, lblRecheckOk);
137420 sqlite3VdbeAddOp2(v, OP_IsNull, regIdx-1, lblRecheckOk);
137421 VdbeCoverage(v);
137431 x = *sqlite3VdbeGetOp(v, addrConflictCk);
137441 sqlite3VdbeAddOp4(v, x.opcode, x.p1, p2, x.p3, zP4, x.p4type);
137442 sqlite3VdbeChangeP5(v, x.p5);
137443 VdbeCoverageIf(v, p2!=x.p2);
137451 sqlite3VdbeJumpHere(v, addrBypass); /* Terminate the recheck bypass */
137457 sqlite3VdbeResolveLabel(v, addrUniqueOk);
137463 sqlite3VdbeGoto(v, upsertIpkDelay+1);
137464 sqlite3VdbeJumpHere(v, upsertIpkReturn);
137471 sqlite3VdbeGoto(v, ipkTop);
137472 VdbeComment((v, "Do IPK REPLACE"));
137474 sqlite3VdbeJumpHere(v, ipkBottom);
137481 sqlite3VdbeAddOp2(v, OP_IfNot, regTrigCnt, lblRecheckOk);VdbeCoverage(v);
137484 sqlite3VdbeAddOp3(v, OP_Eq, regNewData, addrRecheck, regOldData);
137485 sqlite3VdbeChangeP5(v, SQLITE_NOTNULL);
137486 VdbeCoverage(v);
137488 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, addrRecheck, regNewData);
137489 VdbeCoverage(v);
137492 sqlite3VdbeGoto(v, addrRecheck);
137494 sqlite3VdbeResolveLabel(v, lblRecheckOk);
137500 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNewData+1, pTab->nNVCol, regRec);
137501 sqlite3SetMakeRecordP5(v, pTab);
137503 sqlite3TableAffinity(v, pTab, 0);
137508 VdbeModuleComment((v, "END: GenCnstCks(%d)", seenReplace));
137518 SQLITE_PRIVATE void sqlite3SetMakeRecordP5(Vdbe *v, Table *pTab){
137529 sqlite3VdbeChangeP5(v, i+1);
137546 Vdbe *v = pParse->pVdbe;
137550 sqlite3VdbeAddOp2(v, OP_Integer, 0, r);
137551 sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
137552 sqlite3VdbeChangeP5(v, OPFLAG_ISNOOP);
137579 Vdbe *v; /* Prepared statements under construction */
137589 v = pParse->pVdbe;
137590 assert( v!=0 );
137599 sqlite3VdbeAddOp2(v, OP_IsNull, aRegIdx[i], sqlite3VdbeCurrentAddr(v)+2);
137600 VdbeCoverage(v);
137610 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iIdxCur+i, aRegIdx[i],
137613 sqlite3VdbeChangeP5(v, pik_flags);
137628 sqlite3VdbeAddOp3(v, OP_Insert, iDataCur, aRegIdx[i], regNewData);
137630 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
137632 sqlite3VdbeChangeP5(v, pik_flags);
137670 Vdbe *v;
137684 v = pParse->pVdbe;
137685 assert( v!=0 );
137703 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
137705 sqlite3VdbeChangeP5(v, p5);
137706 VdbeComment((v, "%s", pIdx->zName));
137816 Vdbe *v; /* The VDBE we are building */
138024 v = sqlite3GetVdbe(pParse);
138030 sqlite3VdbeAddOp2(v, OP_Null, 0, regData);
138056 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0); VdbeCoverage(v);
138057 emptyDestTest = sqlite3VdbeAddOp0(v, OP_Goto);
138058 sqlite3VdbeJumpHere(v, addr1);
138063 emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
138065 addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
138067 sqlite3VdbeVerifyAbortable(v, onError);
138068 addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
138069 VdbeCoverage(v);
138071 sqlite3VdbeJumpHere(v, addr2);
138075 addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
138077 addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
138082 sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
138089 sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
138094 sqlite3VdbeAddOp3(v, OP_RowCell, iDest, iSrc, regRowid);
138096 sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
138098 sqlite3VdbeChangeP4(v, -1, (char*)pDest, P4_TABLE);
138100 sqlite3VdbeChangeP5(v, insFlags);
138102 sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
138103 sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
138104 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
138115 sqlite3VdbeAddOp3(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc);
138117 VdbeComment((v, "%s", pSrcIdx->zName));
138118 sqlite3VdbeAddOp3(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest);
138120 sqlite3VdbeChangeP5(v, OPFLAG_BULKCSR);
138121 VdbeComment((v, "%s", pDestIdx->zName));
138122 addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0); VdbeCoverage(v);
138144 sqlite3VdbeAddOp1(v, OP_SeekEnd, iDest);
138145 sqlite3VdbeAddOp2(v, OP_RowCell, iDest, iSrc);
138151 sqlite3VdbeAddOp3(v, OP_RowData, iSrc, regData, 1);
138159 sqlite3VdbeAddOp2(v, OP_IdxInsert, iDest, regData);
138160 sqlite3VdbeChangeP5(v, idxInsFlags|OPFLAG_APPEND);
138161 sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1); VdbeCoverage(v);
138162 sqlite3VdbeJumpHere(v, addr1);
138163 sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
138164 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
138166 if( emptySrcTest ) sqlite3VdbeJumpHere(v, emptySrcTest);
138171 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
138172 sqlite3VdbeJumpHere(v, emptyDestTest);
138173 sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
139058 # define SQLITE_EXTENSION_INIT2(v) sqlite3_api=v;
139065 # define SQLITE_EXTENSION_INIT2(v) (void)v; /* unused parameter */
140842 Vdbe *v, /* The query under construction */
140846 sqlite3VdbeSetNumCols(v, n==0 ? 1 : n);
140848 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, pPragma->zName, SQLITE_STATIC);
140852 sqlite3VdbeSetColName(v, i, COLNAME_NAME, pragCName[j], SQLITE_STATIC);
140860 static void returnSingleInt(Vdbe *v, i64 value){
140861 sqlite3VdbeAddOp4Dup8(v, OP_Int64, 0, 1, 0, (const u8*)&value, P4_INT64);
140862 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
140869 Vdbe *v, /* Prepared statement under construction */
140873 sqlite3VdbeLoadString(v, 1, (const char*)zValue);
140874 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
140976 Vdbe *v, /* The prepared statement being created */
141011 sqlite3VdbeMultiLoad(v, 1, "sissii",
141028 static int integrityCheckResultRow(Vdbe *v){
141030 sqlite3VdbeAddOp2(v, OP_ResultRow, 3, 1);
141031 addr = sqlite3VdbeAddOp3(v, OP_IfPos, 1, sqlite3VdbeCurrentAddr(v)+2, 1);
141032 VdbeCoverage(v);
141033 sqlite3VdbeAddOp0(v, OP_Halt);
141068 Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */
141071 if( v==0 ) return;
141072 sqlite3VdbeRunOnlyOnce(v);
141124 sqlite3VdbeSetNumCols(v, 1);
141125 sqlite3VdbeSetColName(v, 0, COLNAME_NAME, aFcntl[0], SQLITE_TRANSIENT);
141126 returnSingleText(v, aFcntl[0]);
141157 setPragmaResultColumnNames(v, pPragma);
141194 sqlite3VdbeUsesBtree(v, iDb);
141197 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize));
141198 aOp = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize, iLn);
141206 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
141230 returnSingleInt(v, size);
141269 returnSingleInt(v, b);
141296 sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
141304 sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, (int)x);
141306 sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
141352 returnSingleText(v, zRet);
141393 sqlite3VdbeUsesBtree(v, ii);
141394 sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
141397 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
141415 returnSingleInt(v, iLimit);
141433 returnSingleInt(v, sqlite3BtreeGetAutoVacuum(pBt));
141459 int iAddr = sqlite3VdbeCurrentAddr(v);
141460 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6));
141461 aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
141468 sqlite3VdbeUsesBtree(v, iDb);
141487 sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
141488 addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); VdbeCoverage(v);
141489 sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
141490 sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
141491 sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); VdbeCoverage(v);
141492 sqlite3VdbeJumpHere(v, addr);
141512 returnSingleInt(v, pDb->pSchema->cache_size);
141546 returnSingleInt(v,
141600 returnSingleInt(v, sz);
141621 returnSingleInt(v, db->temp_store);
141641 returnSingleText(v, sqlite3_temp_directory);
141688 returnSingleText(v, sqlite3_data_directory);
141729 returnSingleText(v, proxy_file_path);
141761 returnSingleInt(v, pDb->safety_level-1);
141781 setPragmaResultColumnNames(v, pPragma);
141782 returnSingleInt(v, (db->flags & pPragma->iArg)!=0 );
141817 sqlite3VdbeAddOp0(v, OP_Expire);
141876 sqlite3VdbeMultiLoad(v, 1, pPragma->iArg ? "issisii" : "issisi",
141956 sqlite3VdbeMultiLoad(v, 1, "sssiii",
141977 sqlite3VdbeMultiLoad(v, 1, "ssiii",
141984 sqlite3VdbeMultiLoad(v, 2, "siiiX",
141989 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
142027 sqlite3VdbeMultiLoad(v, 1, "iisX", i, cnum,
142030 sqlite3VdbeMultiLoad(v, 4, "isiX",
142035 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem);
142052 sqlite3VdbeMultiLoad(v, 1, "isisi",
142069 sqlite3VdbeMultiLoad(v, 1, "iss",
142083 sqlite3VdbeMultiLoad(v, 1, "is", i++, pColl->zName);
142098 pragmaFunclistLine(v, p, 1, showInternFunc);
142104 pragmaFunclistLine(v, p, 0, showInternFunc);
142115 sqlite3VdbeMultiLoad(v, 1, "s", pMod->zName);
142124 sqlite3VdbeMultiLoad(v, 1, "s", aPragmaName[i].zName);
142147 sqlite3VdbeMultiLoad(v, 1, "iissssss",
142202 sqlite3VdbeLoadString(v, regResult, pTab->zName);
142214 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
142225 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, 0); VdbeCoverage(v);
142244 sqlite3ExprCodeGetColumnOfTable(v, pTab, 0, iCol, regRow+j);
142245 sqlite3VdbeAddOp2(v, OP_IsNull, regRow+j, addrOk); VdbeCoverage(v);
142251 sqlite3VdbeAddOp4(v, OP_Affinity, regRow, pFK->nCol, 0,
142253 sqlite3VdbeAddOp4Int(v, OP_Found, i, addrOk, regRow, pFK->nCol);
142254 VdbeCoverage(v);
142256 int jmp = sqlite3VdbeCurrentAddr(v)+2;
142257 sqlite3VdbeAddOp3(v, OP_SeekRowid, i, jmp, regRow); VdbeCoverage(v);
142258 sqlite3VdbeGoto(v, addrOk);
142264 sqlite3VdbeAddOp2(v, OP_Rowid, 0, regResult+1);
142266 sqlite3VdbeAddOp2(v, OP_Null, 0, regResult+1);
142268 sqlite3VdbeMultiLoad(v, regResult+2, "siX", pFK->zTo, i-1);
142269 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, 4);
142270 sqlite3VdbeResolveLabel(v, addrOk);
142273 sqlite3VdbeAddOp2(v, OP_Next, 0, addrTop+1); VdbeCoverage(v);
142274 sqlite3VdbeJumpHere(v, addrTop);
142356 sqlite3VdbeAddOp2(v, OP_Integer, mxErr-1, 1); /* reg[1] holds errors left */
142405 sqlite3VdbeAddOp3(v, OP_Null, 0, 8, 8+cnt);
142409 sqlite3VdbeAddOp4(v, OP_IntegrityCk, 1, cnt, 8, (char*)aRoot,P4_INTARRAY);
142410 sqlite3VdbeChangeP5(v, (u16)i);
142411 addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); VdbeCoverage(v);
142412 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
142415 sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 3);
142416 integrityCheckResultRow(v);
142417 sqlite3VdbeJumpHere(v, addr);
142421 sqlite3VdbeLoadString(v, 2, "wrong # of entries in index ");
142438 addr = sqlite3VdbeAddOp3(v, OP_Eq, 8+cnt, 0, 8+iTab);
142439 VdbeCoverageNeverNull(v);
142440 sqlite3VdbeLoadString(v, 4, pIdx->zName);
142441 sqlite3VdbeAddOp3(v, OP_Concat, 4, 2, 3);
142442 integrityCheckResultRow(v);
142443 sqlite3VdbeJumpHere(v, addr);
142470 sqlite3VdbeAddOp3(v, OP_Null, 1, r2, r2+pPk->nKeyCol-1);
142477 sqlite3VdbeAddOp2(v, OP_Integer, 0, 7);
142479 sqlite3VdbeAddOp2(v, OP_Integer, 0, 8+j); /* index entries counter */
142483 sqlite3VdbeAddOp2(v, OP_Rewind, iDataCur, 0); VdbeCoverage(v);
142484 loopTop = sqlite3VdbeAddOp2(v, OP_AddImm, 7, 1);
142505 sqlite3VdbeAddOp3(v, OP_Column, iDataCur, mxCol, 3);
142506 sqlite3VdbeTypeofColumn(v, 3);
142514 a1 = sqlite3VdbeAddOp4Int(v, OP_IdxGT, iDataCur, 0,r2,pPk->nKeyCol);
142515 VdbeCoverage(v);
142516 sqlite3VdbeAddOp1(v, OP_IsNull, r2); VdbeCoverage(v);
142520 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
142521 integrityCheckResultRow(v);
142522 sqlite3VdbeJumpHere(v, a1);
142523 sqlite3VdbeJumpHere(v, a1+1);
142558 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
142586 int jmp2 = sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
142587 VdbeCoverage(v);
142589 sqlite3VdbeChangeP5(v, 0x0f); /* INT, REAL, TEXT, or BLOB */
142592 sqlite3VdbeChangeP5(v, 0x0d); /* INT, TEXT, or BLOB */
142597 sqlite3VdbeAddOp3(v, OP_Column, p1, p3, 3);
142598 sqlite3ColumnDefault(v, pTab, j, 3);
142599 jmp3 = sqlite3VdbeAddOp2(v, OP_NotNull, 3, labelOk);
142600 VdbeCoverage(v);
142604 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
142606 sqlite3VdbeGoto(v, labelError);
142607 sqlite3VdbeJumpHere(v, jmp2);
142608 sqlite3VdbeJumpHere(v, jmp3);
142623 sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
142625 sqlite3VdbeChangeP5(v, aStdTypeMask[pCol->eCType-1]);
142626 VdbeCoverage(v);
142630 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
142634 sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
142635 sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */
142636 VdbeCoverage(v);
142639 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
142643 sqlite3VdbeAddOp4Int(v, OP_IsType, p1, labelOk, p3, p4);
142644 sqlite3VdbeChangeP5(v, 0x1b); /* NULL, INT, FLOAT, or BLOB */
142645 VdbeCoverage(v);
142647 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, j, 3);
142649 sqlite3VdbeAddOp4(v, OP_Affinity, 3, 1, 0, "C", P4_STATIC);
142650 sqlite3VdbeAddOp4Int(v, OP_IsType, -1, labelOk, 3, p4);
142651 sqlite3VdbeChangeP5(v, 0x1c); /* NULL, TEXT, or BLOB */
142652 VdbeCoverage(v);
142655 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
142657 sqlite3VdbeResolveLabel(v, labelError);
142658 integrityCheckResultRow(v);
142659 sqlite3VdbeResolveLabel(v, labelOk);
142675 sqlite3VdbeResolveLabel(v, addrCkFault);
142679 sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, zErr, P4_DYNAMIC);
142680 integrityCheckResultRow(v);
142681 sqlite3VdbeResolveLabel(v, addrCkOk);
142695 sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);/* increment entry count */
142697 jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, iIdxCur+j, ckUniq, r1,
142698 pIdx->nColumn); VdbeCoverage(v);
142699 sqlite3VdbeLoadString(v, 3, "row ");
142700 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
142701 sqlite3VdbeLoadString(v, 4, " missing from index ");
142702 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
142703 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
142704 sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 3);
142705 jmp4 = integrityCheckResultRow(v);
142706 sqlite3VdbeJumpHere(v, jmp2);
142714 sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur+j, 3);
142715 jmp7 = sqlite3VdbeAddOp3(v, OP_Eq, 3, 0, r1+pIdx->nColumn-1);
142716 VdbeCoverageNeverNull(v);
142717 sqlite3VdbeLoadString(v, 3,
142719 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
142720 sqlite3VdbeLoadString(v, 4, " of index ");
142721 sqlite3VdbeGoto(v, jmp5-1);
142722 sqlite3VdbeJumpHere(v, jmp7);
142731 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur+j, kk, 3);
142732 sqlite3VdbeAddOp3(v, OP_Ne, 3, label6, r1+kk); VdbeCoverage(v);
142735 int jmp6 = sqlite3VdbeAddOp0(v, OP_Goto);
142736 sqlite3VdbeResolveLabel(v, label6);
142737 sqlite3VdbeLoadString(v, 3, "row ");
142738 sqlite3VdbeAddOp3(v, OP_Concat, 7, 3, 3);
142739 sqlite3VdbeLoadString(v, 4, " values differ from index ");
142740 sqlite3VdbeGoto(v, jmp5-1);
142741 sqlite3VdbeJumpHere(v, jmp6);
142754 sqlite3VdbeAddOp2(v, OP_IsNull, r1+kk, uniqOk);
142755 VdbeCoverage(v);
142757 jmp6 = sqlite3VdbeAddOp1(v, OP_Next, iIdxCur+j); VdbeCoverage(v);
142758 sqlite3VdbeGoto(v, uniqOk);
142759 sqlite3VdbeJumpHere(v, jmp6);
142760 sqlite3VdbeAddOp4Int(v, OP_IdxGT, iIdxCur+j, uniqOk, r1,
142761 pIdx->nKeyCol); VdbeCoverage(v);
142762 sqlite3VdbeLoadString(v, 3, "non-unique entry in index ");
142763 sqlite3VdbeGoto(v, jmp5);
142764 sqlite3VdbeResolveLabel(v, uniqOk);
142766 sqlite3VdbeJumpHere(v, jmp4);
142770 sqlite3VdbeAddOp2(v, OP_Next, iDataCur, loopTop); VdbeCoverage(v);
142771 sqlite3VdbeJumpHere(v, loopTop-1);
142800 sqlite3VdbeAddOp3(v, OP_VCheck, i, 3, isQuick);
142802 sqlite3VdbeAppendP4(v, pTab, P4_TABLEREF);
142803 a1 = sqlite3VdbeAddOp1(v, OP_IsNull, 3); VdbeCoverage(v);
142804 integrityCheckResultRow(v);
142805 sqlite3VdbeJumpHere(v, a1);
142823 aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
142831 sqlite3VdbeChangeP3(v, 0, sqlite3VdbeCurrentAddr(v)-2);
142881 returnSingleText(v, encnames[ENC(pParse->db)].zName);
142941 sqlite3VdbeUsesBtree(v, iDb);
142949 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setCookie));
142950 aOp = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
142970 sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(readCookie));
142971 aOp = sqlite3VdbeAddOpList(v, ArraySize(readCookie),readCookie,0);
142976 sqlite3VdbeReusable(v);
142994 sqlite3VdbeLoadString(v, 1, zOpt);
142995 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
142997 sqlite3VdbeReusable(v);
143021 sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
143022 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
143038 returnSingleInt(v,
143214 sqlite3VdbeAddOp4Int(v, OP_IfSizeBetween, iTabCur,
143215 sqlite3VdbeCurrentAddr(v)+2+(opMask&1),
143218 VdbeCoverage(v);
143220 sqlite3VdbeAddOp2(v, OP_Rewind, iTabCur,
143221 sqlite3VdbeCurrentAddr(v)+2+(opMask&1));
143222 VdbeCoverage(v);
143228 sqlite3VdbeAddOp4(v, OP_String8, 0, r1, 0, zSubSql, P4_DYNAMIC);
143229 sqlite3VdbeAddOp2(v, OP_ResultRow, r1, 1);
143231 sqlite3VdbeAddOp4(v, OP_SqlExec, nLimit ? 0x02 : 00, nLimit, 0,
143236 sqlite3VdbeAddOp0(v, OP_Expire);
143246 aOp = sqlite3VdbeGetOp(v, 0);
143247 iEnd = sqlite3VdbeCurrentAddr(v);
143269 returnSingleInt(v, db->busyTimeout);
143289 returnSingleInt(v, sqlite3_soft_heap_limit64(-1));
143310 returnSingleInt(v, sqlite3_hard_heap_limit64(-1));
143329 returnSingleInt(v, sqlite3_limit(db, SQLITE_LIMIT_WORKER_THREADS, -1));
143348 returnSingleInt(v, db->nAnalysisLimit); /* IMP: R-57594-65522 */
143374 sqlite3VdbeMultiLoad(v, 1, "ss", db->aDb[i].zDbSName, zState);
143397 sqlite3VdbeVerifyNoResultRow(v);
145529 Vdbe *v = pParse->pVdbe;
145534 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase+nOBSat, nBase-nOBSat, regOut);
145551 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
145580 pSort->addrPush = sqlite3VdbeCurrentAddr(v);
145596 sqlite3VdbeAddOp2(v, OP_Sequence, pSort->iECursor, regBase+nExpr);
145614 addrFirst = sqlite3VdbeAddOp1(v, OP_IfNot, regBase+nExpr);
145616 addrFirst = sqlite3VdbeAddOp1(v, OP_SequenceTest, pSort->iECursor);
145618 VdbeCoverage(v);
145619 sqlite3VdbeAddOp3(v, OP_Compare, regPrevKey, regBase, pSort->nOBSat);
145620 pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
145625 sqlite3VdbeChangeP4(v, -1, (char*)pKI, P4_KEYINFO);
145630 addrJmp = sqlite3VdbeCurrentAddr(v);
145631 sqlite3VdbeAddOp3(v, OP_Jump, addrJmp+1, 0, addrJmp+1); VdbeCoverage(v);
145634 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
145635 sqlite3VdbeAddOp1(v, OP_ResetSorter, pSort->iECursor);
145637 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
145638 VdbeCoverage(v);
145640 sqlite3VdbeJumpHere(v, addrFirst);
145642 sqlite3VdbeJumpHere(v, addrJmp);
145661 sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
145662 VdbeCoverage(v);
145663 sqlite3VdbeAddOp2(v, OP_Last, iCsr, 0);
145664 iSkip = sqlite3VdbeAddOp4Int(v, OP_IdxLE,
145666 VdbeCoverage(v);
145667 sqlite3VdbeAddOp1(v, OP_Delete, iCsr);
145677 sqlite3VdbeAddOp4Int(v, op, pSort->iECursor, regRecord,
145680 sqlite3VdbeChangeP2(v, iSkip,
145681 pSort->labelOBLopt ? pSort->labelOBLopt : sqlite3VdbeCurrentAddr(v));
145684 pSort->addrPushEnd = sqlite3VdbeCurrentAddr(v)-1;
145692 Vdbe *v, /* Generate code into this VM */
145697 sqlite3VdbeAddOp3(v, OP_IfPos, iOffset, iContinue, 1); VdbeCoverage(v);
145698 VdbeComment((v, "OFFSET"));
145755 Vdbe *v = pParse->pVdbe;
145767 iJump = sqlite3VdbeCurrentAddr(v) + nResultCol;
145771 sqlite3VdbeAddOp3(v, OP_Ne, regElem+i, iJump, regPrev+i);
145772 VdbeCoverage(v);
145774 sqlite3VdbeAddOp3(v, OP_Eq, regElem+i, addrRepeat, regPrev+i);
145775 VdbeCoverage(v);
145777 sqlite3VdbeChangeP4(v, -1, (const char *)pColl, P4_COLLSEQ);
145778 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
145780 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
145781 sqlite3VdbeAddOp3(v, OP_Copy, regElem, regPrev, nResultCol-1);
145792 sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, regElem, nResultCol);
145793 VdbeCoverage(v);
145794 sqlite3VdbeAddOp3(v, OP_MakeRecord, regElem, nResultCol, r1);
145795 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iTab, r1, regElem, nResultCol);
145796 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
145838 Vdbe *v = pParse->pVdbe;
145839 sqlite3VdbeChangeToNoop(v, iOpenEphAddr);
145840 if( sqlite3VdbeGetOp(v, iOpenEphAddr+1)->opcode==OP_Explain ){
145841 sqlite3VdbeChangeToNoop(v, iOpenEphAddr+1);
145848 VdbeOp *pOp = sqlite3VdbeGetOp(v, iOpenEphAddr);
145961 Vdbe *v = pParse->pVdbe;
145978 assert( v );
145984 codeOffset(v, p->iOffset, iContinue);
146011 sqlite3VdbeAddOp3(v, OP_Column, srcTab, i, regResult+i);
146012 VdbeComment((v, "%s", p->pEList->a[i].zEName));
146051 VdbeOp *pOp = sqlite3VdbeGetOp(v, pSort->addrSortIndex);
146112 codeOffset(v, p->iOffset, iContinue);
146124 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1);
146125 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
146135 sqlite3VdbeAddOp3(v, OP_IdxDelete, iParm, regResult, nResultCol);
146151 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r1+nPrefixReg);
146159 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
146169 int addr = sqlite3VdbeCurrentAddr(v) + 4;
146170 sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, addr, r1, 0);
146171 VdbeCoverage(v);
146172 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm+1, r1,regResult,nResultCol);
146181 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, r2);
146182 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, r2);
146183 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
146201 sqlite3VdbeAddOp2(v, OP_IsNull, regResult, iBreak); VdbeCoverage(v);
146203 sqlite3VdbeAddOp3(v, OP_MakeRecord,
146206 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regResult);
146208 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, i2);
146231 sqlite3VdbeAddOp4(v, OP_MakeRecord, regResult, nResultCol,
146233 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regResult, nResultCol);
146235 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pDest->iSDParm2, 0,
146248 sqlite3VdbeAddOp2(v, OP_Integer, 1, iParm);
146279 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
146281 sqlite3VdbeAddOp2(v, OP_ResultRow, regResult, nResultCol);
146309 addrTest = sqlite3VdbeAddOp4Int(v, OP_Found, iParm+1, 0,
146311 VdbeCoverage(v);
146313 sqlite3VdbeAddOp3(v, OP_MakeRecord, regResult, nResultCol, r3);
146315 sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm+1, r3);
146316 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
146319 sqlite3VdbeAddOp2(v, OP_SCopy,
146323 sqlite3VdbeAddOp2(v, OP_Sequence, iParm, r2+nKey);
146324 sqlite3VdbeAddOp3(v, OP_MakeRecord, r2, nKey+2, r1);
146325 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, r2, nKey+2);
146326 if( addrTest ) sqlite3VdbeJumpHere(v, addrTest);
146353 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
146507 Vdbe *v = pParse->pVdbe; /* The prepared statement */
146539 sqlite3VdbeScanStatusRange(v, addrExplain,pSort->addrPush,pSort->addrPushEnd);
146540 sqlite3VdbeScanStatusCounters(v, addrExplain, addrExplain, pSort->addrPush);
146545 sqlite3VdbeAddOp2(v, OP_Gosub, pSort->regReturn, pSort->labelBkOut);
146546 sqlite3VdbeGoto(v, addrBreak);
146547 sqlite3VdbeResolveLabel(v, pSort->labelBkOut);
146563 sqlite3VdbeAddOp2(v, OP_Null, 0, pDest->iSdst);
146580 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
146582 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iSortTab, regSortOut,
146584 if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
146585 addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
146586 VdbeCoverage(v);
146588 sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
146591 addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
146592 codeOffset(v, p->iOffset, addrContinue);
146596 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
146615 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
146617 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey);
146618 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCsr,
146619 sqlite3VdbeCurrentAddr(v)+1, regKey);
146625 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iKey++, regKey+k);
146627 iJmp = sqlite3VdbeCurrentAddr(v);
146628 sqlite3VdbeAddOp4Int(v, OP_SeekGE, iCsr, iJmp+2, regKey, nKey);
146629 sqlite3VdbeAddOp4Int(v, OP_IdxLE, iCsr, iJmp+3, regKey, nKey);
146630 sqlite3VdbeAddOp1(v, OP_NullRow, iCsr);
146649 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, iRead, regRow+i);
146650 VdbeComment((v, "%s", aOutEx[i].zEName));
146653 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
146657 sqlite3VdbeAddOp3(v, OP_Column, iSortTab, nKey+bSeq, regRow);
146658 sqlite3VdbeAddOp2(v, OP_NewRowid, iParm, regRowid);
146659 sqlite3VdbeAddOp3(v, OP_Insert, iParm, regRow, regRowid);
146660 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
146666 sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, nColumn, regRowid,
146668 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, regRowid, regRow, nColumn);
146679 sqlite3VdbeAddOp3(v, OP_MakeRecord,regRow+(i2<0),nColumn-(i2<0),r1);
146681 sqlite3VdbeAddOp3(v, OP_Insert, iParm, r1, regRow);
146683 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iParm, r1, regRow, i2);
146692 sqlite3VdbeAddOp2(v, OP_ResultRow, pDest->iSdst, nColumn);
146694 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
146709 sqlite3VdbeResolveLabel(v, addrContinue);
146711 sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
146713 sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
146715 sqlite3VdbeScanStatusRange(v, addrExplain, sqlite3VdbeCurrentAddr(v)-1, -1);
146716 if( pSort->regReturn ) sqlite3VdbeAddOp1(v, OP_Return, pSort->regReturn);
146717 sqlite3VdbeResolveLabel(v, addrBreak);
146903 Vdbe *v = pParse->pVdbe;
146922 sqlite3VdbeSetColName(v, i, COLNAME_DATABASE, zOrigDb, SQLITE_TRANSIENT);
146923 sqlite3VdbeSetColName(v, i, COLNAME_TABLE, zOrigTab, SQLITE_TRANSIENT);
146924 sqlite3VdbeSetColName(v, i, COLNAME_COLUMN, zOrigCol, SQLITE_TRANSIENT);
146928 sqlite3VdbeSetColName(v, i, COLNAME_DECLTYPE, zType, SQLITE_TRANSIENT);
146968 Vdbe *v = pParse->pVdbe;
146983 assert( v!=0 );
146988 sqlite3VdbeSetNumCols(v, pEList->nExpr);
146999 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_TRANSIENT);
147015 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zName, SQLITE_DYNAMIC);
147017 sqlite3VdbeSetColName(v, i, COLNAME_NAME, zCol, SQLITE_TRANSIENT);
147022 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
147332 Vdbe *v = 0;
147350 v = sqlite3GetVdbe(pParse);
147351 assert( v!=0 );
147353 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
147354 VdbeComment((v, "LIMIT counter"));
147356 sqlite3VdbeGoto(v, iBreak);
147363 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
147364 VdbeComment((v, "LIMIT counter"));
147365 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
147371 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
147372 VdbeComment((v, "OFFSET counter"));
147373 sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
147374 VdbeComment((v, "LIMIT+OFFSET"));
147487 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
147547 sqlite3VdbeAddOp3(v, OP_OpenPseudo, iCurrent, regCurrent, nCol);
147550 sqlite3VdbeAddOp4(v, OP_OpenEphemeral, iQueue, pOrderBy->nExpr+2, 0,
147554 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iQueue, nCol);
147556 VdbeComment((v, "Queue table"));
147558 p->addrOpenEphm[0] = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iDistinct, 0);
147590 addrTop = sqlite3VdbeAddOp2(v, OP_Rewind, iQueue, addrBreak); VdbeCoverage(v);
147593 sqlite3VdbeAddOp1(v, OP_NullRow, iCurrent); /* To reset column cache */
147595 sqlite3VdbeAddOp3(v, OP_Column, iQueue, pOrderBy->nExpr+1, regCurrent);
147597 sqlite3VdbeAddOp2(v, OP_RowData, iQueue, regCurrent);
147599 sqlite3VdbeAddOp1(v, OP_Delete, iQueue);
147603 codeOffset(v, regOffset, addrCont);
147607 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, regLimit, addrBreak);
147608 VdbeCoverage(v);
147610 sqlite3VdbeResolveLabel(v, addrCont);
147622 sqlite3VdbeGoto(v, addrTop);
147623 sqlite3VdbeResolveLabel(v, addrBreak);
147736 Vdbe *v; /* Generate code to this VDBE */
147753 v = sqlite3GetVdbe(pParse);
147754 assert( v!=0 ); /* The VDBE already created by calling function */
147760 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, dest.iSDParm, p->pEList->nExpr);
147817 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
147818 VdbeComment((v, "Jump ahead if LIMIT reached"));
147820 sqlite3VdbeAddOp3(v, OP_OffsetLimit,
147838 sqlite3VdbeJumpHere(v, addr);
147866 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, unionTab, 0);
147923 sqlite3VdbeAddOp2(v, OP_Rewind, unionTab, iBreak); VdbeCoverage(v);
147924 iStart = sqlite3VdbeCurrentAddr(v);
147927 sqlite3VdbeResolveLabel(v, iCont);
147928 sqlite3VdbeAddOp2(v, OP_Next, unionTab, iStart); VdbeCoverage(v);
147929 sqlite3VdbeResolveLabel(v, iBreak);
147930 sqlite3VdbeAddOp2(v, OP_Close, unionTab, 0);
147950 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab1, 0);
147967 addr = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, tab2, 0);
147995 sqlite3VdbeAddOp2(v, OP_Rewind, tab1, iBreak); VdbeCoverage(v);
147997 iStart = sqlite3VdbeAddOp2(v, OP_RowData, tab1, r1);
147998 sqlite3VdbeAddOp4Int(v, OP_NotFound, tab2, iCont, r1, 0);
147999 VdbeCoverage(v);
148003 sqlite3VdbeResolveLabel(v, iCont);
148004 sqlite3VdbeAddOp2(v, OP_Next, tab1, iStart); VdbeCoverage(v);
148005 sqlite3VdbeResolveLabel(v, iBreak);
148006 sqlite3VdbeAddOp2(v, OP_Close, tab2, 0);
148007 sqlite3VdbeAddOp2(v, OP_Close, tab1, 0);
148060 sqlite3VdbeChangeP2(v, addr, nCol);
148061 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
148124 Vdbe *v = pParse->pVdbe;
148128 addr = sqlite3VdbeCurrentAddr(v);
148135 addr1 = sqlite3VdbeAddOp1(v, OP_IfNot, regPrev); VdbeCoverage(v);
148136 addr2 = sqlite3VdbeAddOp4(v, OP_Compare, pIn->iSdst, regPrev+1, pIn->nSdst,
148138 sqlite3VdbeAddOp3(v, OP_Jump, addr2+2, iContinue, addr2+2); VdbeCoverage(v);
148139 sqlite3VdbeJumpHere(v, addr1);
148140 sqlite3VdbeAddOp3(v, OP_Copy, pIn->iSdst, regPrev+1, pIn->nSdst-1);
148141 sqlite3VdbeAddOp2(v, OP_Integer, 1, regPrev);
148147 codeOffset(v, p->iOffset, iContinue);
148157 sqlite3VdbeAddOp3(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst, r1);
148158 sqlite3VdbeAddOp2(v, OP_NewRowid, pDest->iSDParm, r2);
148159 sqlite3VdbeAddOp3(v, OP_Insert, pDest->iSDParm, r1, r2);
148160 sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
148173 sqlite3VdbeAddOp4(v, OP_MakeRecord, pIn->iSdst, pIn->nSdst,
148175 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pDest->iSDParm, r1,
148178 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pDest->iSDParm2, 0,
148208 sqlite3VdbeAddOp1(v, OP_Yield, pDest->iSDParm);
148222 sqlite3VdbeAddOp2(v, OP_ResultRow, pIn->iSdst, pIn->nSdst);
148230 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
148235 sqlite3VdbeResolveLabel(v, iContinue);
148236 sqlite3VdbeAddOp1(v, OP_Return, regReturn);
148336 Vdbe *v; /* Generate code to this VDBE */
148372 v = pParse->pVdbe;
148373 assert( v!=0 ); /* Already thrown the error if VDBE alloc failed */
148442 sqlite3VdbeAddOp2(v, OP_Integer, 0, regPrev);
148485 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
148487 sqlite3VdbeAddOp2(v, OP_Copy, regLimitA, regLimitB);
148506 addrSelectA = sqlite3VdbeCurrentAddr(v) + 1;
148507 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrA, 0, addrSelectA);
148508 VdbeComment((v, "left SELECT"));
148512 sqlite3VdbeEndCoroutine(v, regAddrA);
148513 sqlite3VdbeJumpHere(v, addr1);
148518 addrSelectB = sqlite3VdbeCurrentAddr(v) + 1;
148519 addr1 = sqlite3VdbeAddOp3(v, OP_InitCoroutine, regAddrB, 0, addrSelectB);
148520 VdbeComment((v, "right SELECT"));
148529 sqlite3VdbeEndCoroutine(v, regAddrB);
148534 VdbeNoopComment((v, "Output routine for A"));
148543 VdbeNoopComment((v, "Output routine for B"));
148556 VdbeNoopComment((v, "eof-A subroutine"));
148557 addrEofA = sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
148558 addrEofA_noB = sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, labelEnd);
148559 VdbeCoverage(v);
148560 sqlite3VdbeGoto(v, addrEofA);
148571 VdbeNoopComment((v, "eof-B subroutine"));
148572 addrEofB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
148573 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, labelEnd); VdbeCoverage(v);
148574 sqlite3VdbeGoto(v, addrEofB);
148579 VdbeNoopComment((v, "A-lt-B subroutine"));
148580 addrAltB = sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
148581 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
148582 sqlite3VdbeGoto(v, labelCmpr);
148592 VdbeNoopComment((v, "A-eq-B subroutine"));
148594 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA); VdbeCoverage(v);
148595 sqlite3VdbeGoto(v, labelCmpr);
148600 VdbeNoopComment((v, "A-gt-B subroutine"));
148601 addrAgtB = sqlite3VdbeCurrentAddr(v);
148603 sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
148605 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
148606 sqlite3VdbeGoto(v, labelCmpr);
148610 sqlite3VdbeJumpHere(v, addr1);
148611 sqlite3VdbeAddOp2(v, OP_Yield, regAddrA, addrEofA_noB); VdbeCoverage(v);
148612 sqlite3VdbeAddOp2(v, OP_Yield, regAddrB, addrEofB); VdbeCoverage(v);
148616 sqlite3VdbeResolveLabel(v, labelCmpr);
148617 sqlite3VdbeAddOp4(v, OP_Permutation, 0, 0, 0, (char*)aPermute, P4_INTARRAY);
148618 sqlite3VdbeAddOp4(v, OP_Compare, destA.iSdst, destB.iSdst, nOrderBy,
148620 sqlite3VdbeChangeP5(v, OPFLAG_PERMUTE);
148621 sqlite3VdbeAddOp3(v, OP_Jump, addrAltB, addrAeqB, addrAgtB); VdbeCoverage(v);
148625 sqlite3VdbeResolveLabel(v, labelEnd);
151565 Vdbe *v = pParse->pVdbe;
151574 sqlite3VdbeAddOp3(v, OP_Null, 0, pAggInfo->iFirstReg,
151586 pFunc->iDistAddr = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
151616 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
151630 Vdbe *v = pParse->pVdbe;
151662 iTop = sqlite3VdbeAddOp1(v, OP_Rewind, pF->iOBTab); VdbeCoverage(v);
151664 sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, nKey+j, regAgg+j);
151670 sqlite3VdbeAddOp3(v, OP_Column, pF->iOBTab, iBaseCol+j, regSubtype);
151671 sqlite3VdbeAddOp2(v, OP_SetSubtype, regSubtype, regAgg+j);
151675 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i));
151676 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
151677 sqlite3VdbeChangeP5(v, (u16)nArg);
151678 sqlite3VdbeAddOp2(v, OP_Next, pF->iOBTab, iTop+1); VdbeCoverage(v);
151679 sqlite3VdbeJumpHere(v, iTop);
151682 sqlite3VdbeAddOp2(v, OP_AggFinal, AggInfoFuncReg(pAggInfo,i),
151684 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
151710 Vdbe *v = pParse->pVdbe;
151748 sqlite3VdbeAddOp2(v, OP_Copy, regAcc, regHit);
151783 sqlite3VdbeAddOp2(v, OP_Sequence, pF->iOBTab, regAgg+jj);
151795 sqlite3VdbeAddOp2(v, OP_GetSubtype, regBase+kk, regAgg+jj);
151816 sqlite3VdbeAddOp3(v, OP_MakeRecord, regAgg, regAggSz-1,
151818 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pF->iOBTab, regAgg+regAggSz-1,
151835 sqlite3VdbeAddOp4(v, OP_CollSeq, regHit, 0, 0,
151838 sqlite3VdbeAddOp3(v, OP_AggStep, 0, regAgg, AggInfoFuncReg(pAggInfo,i));
151839 sqlite3VdbeAppendP4(v, pF->pFunc, P4_FUNCDEF);
151840 sqlite3VdbeChangeP5(v, (u16)nArg);
151844 sqlite3VdbeResolveLabel(v, addrNext);
151852 addrHitTest = sqlite3VdbeAddOp1(v, OP_If, regHit); VdbeCoverage(v);
151861 sqlite3VdbeJumpHereOrPopInst(v, addrHitTest);
152250 Vdbe *v; /* The virtual machine under construction */
152268 v = sqlite3GetVdbe(pParse);
152707 int addrTop = sqlite3VdbeCurrentAddr(v)+1;
152710 sqlite3VdbeAddOp3(v, OP_InitCoroutine, pSubq->regReturn, 0, addrTop);
152711 VdbeComment((v, "%!S", pItem));
152719 sqlite3VdbeEndCoroutine(v, pSubq->regReturn);
152720 VdbeComment((v, "end %!S", pItem));
152721 sqlite3VdbeJumpHere(v, addrTop-1);
152729 sqlite3VdbeAddOp2(v, OP_Gosub, pCteUse->regRtn, pCteUse->addrM9e);
152731 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur);
152732 VdbeComment((v, "%!S", pItem));
152743 sqlite3VdbeAddOp2(v, OP_Gosub, pPriorSubq->regReturn,
152746 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pPrior->iCursor);
152759 topAddr = sqlite3VdbeAddOp0(v, OP_Goto);
152766 onceAddr = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
152767 VdbeComment((v, "materialize %!S", pItem));
152769 VdbeNoopComment((v, "materialize %!S", pItem));
152776 if( onceAddr ) sqlite3VdbeJumpHere(v, onceAddr);
152777 sqlite3VdbeAddOp2(v, OP_Return, pSubq->regReturn, topAddr+1);
152778 VdbeComment((v, "end %!S", pItem));
152779 sqlite3VdbeScanStatusRange(v, addrExplain, addrExplain, -1);
152780 sqlite3VdbeJumpHere(v, topAddr);
152871 sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
152883 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pDest->iSDParm, pEList->nExpr);
152906 sqlite3VdbeChangeOpcode(v, sSort.addrSortIndex, OP_SorterOpen);
152914 sDistinct.addrTnct = sqlite3VdbeAddOp4(v, OP_OpenEphemeral,
152918 sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
152968 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
152981 sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
152982 sqlite3VdbeResolveLabel(v, addrGosub);
152983 VdbeNoopComment((v, "inner-loop subroutine"));
152986 sqlite3VdbeResolveLabel(v, iCont);
152987 sqlite3VdbeAddOp1(v, OP_Return, regGosub);
152988 VdbeComment((v, "end inner-loop subroutine"));
152989 sqlite3VdbeResolveLabel(v, iBreak);
153161 addrSortingIdx = sqlite3VdbeAddOp4(v, OP_SorterOpen,
153177 sqlite3VdbeAddOp2(v, OP_Integer, 0, iAbortFlag);
153178 VdbeComment((v, "clear abort flag"));
153179 sqlite3VdbeAddOp3(v, OP_Null, 0, iAMem, iAMem+pGroupBy->nExpr-1);
153186 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
153250 sqlite3VdbeScanStatusCounters(v, addrExp, 0, sqlite3VdbeCurrentAddr(v));
153251 sqlite3VdbeAddOp3(v, OP_MakeRecord, regBase, nCol, regRecord);
153252 sqlite3VdbeAddOp2(v, OP_SorterInsert, pAggInfo->sortingIdx, regRecord);
153253 sqlite3VdbeScanStatusRange(v, addrExp, sqlite3VdbeCurrentAddr(v)-2, -1);
153260 sqlite3VdbeScanStatusCounters(v, addrExp, sqlite3VdbeCurrentAddr(v), 0);
153261 sqlite3VdbeAddOp3(v, OP_OpenPseudo, sortPTab, sortOut, nCol);
153262 sqlite3VdbeAddOp2(v, OP_SorterSort, pAggInfo->sortingIdx, addrEnd);
153263 VdbeComment((v, "GROUP BY sort")); VdbeCoverage(v);
153265 sqlite3VdbeScanStatusRange(v, addrExp, -1, sortPTab);
153266 sqlite3VdbeScanStatusRange(v, addrExp, -1, pAggInfo->sortingIdx);
153297 sqlite3VdbeChangeToNoop(v, sSort.addrSortIndex);
153305 addrTopOfLoop = sqlite3VdbeCurrentAddr(v);
153307 sqlite3VdbeAddOp3(v, OP_SorterData, pAggInfo->sortingIdx,
153314 sqlite3VdbeAddOp3(v, OP_Column, sortPTab, j, iBMem+j);
153335 sqlite3VdbeAddOp4(v, OP_Compare, iAMem, iBMem, pGroupBy->nExpr,
153337 addr1 = sqlite3VdbeCurrentAddr(v);
153338 sqlite3VdbeAddOp3(v, OP_Jump, addr1+1, 0, addr1+1); VdbeCoverage(v);
153349 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
153350 VdbeComment((v, "output one row"));
153352 sqlite3VdbeAddOp2(v, OP_IfPos, iAbortFlag, addrEnd); VdbeCoverage(v);
153353 VdbeComment((v, "check abort flag"));
153354 sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset);
153355 VdbeComment((v, "reset accumulator"));
153360 sqlite3VdbeJumpHere(v, addr1);
153362 sqlite3VdbeAddOp2(v, OP_Integer, 1, iUseFlag);
153363 VdbeComment((v, "indicate data in accumulator"));
153368 sqlite3VdbeAddOp2(v, OP_SorterNext, pAggInfo->sortingIdx,addrTopOfLoop);
153369 VdbeCoverage(v);
153373 sqlite3VdbeChangeToNoop(v, addrSortingIdx);
153379 sqlite3VdbeAddOp2(v, OP_Gosub, regOutputRow, addrOutputRow);
153380 VdbeComment((v, "output final row"));
153384 sqlite3VdbeGoto(v, addrEnd);
153393 addrSetAbort = sqlite3VdbeCurrentAddr(v);
153394 sqlite3VdbeAddOp2(v, OP_Integer, 1, iAbortFlag);
153395 VdbeComment((v, "set abort flag"));
153396 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
153397 sqlite3VdbeResolveLabel(v, addrOutputRow);
153398 addrOutputRow = sqlite3VdbeCurrentAddr(v);
153399 sqlite3VdbeAddOp2(v, OP_IfPos, iUseFlag, addrOutputRow+2);
153400 VdbeCoverage(v);
153401 VdbeComment((v, "Groupby result generator entry point"));
153402 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
153408 sqlite3VdbeAddOp1(v, OP_Return, regOutputRow);
153409 VdbeComment((v, "end groupby result generator"));
153413 sqlite3VdbeResolveLabel(v, addrReset);
153415 sqlite3VdbeAddOp2(v, OP_Integer, 0, iUseFlag);
153416 VdbeComment((v, "indicate accumulator empty"));
153417 sqlite3VdbeAddOp1(v, OP_Return, regReset);
153480 sqlite3VdbeAddOp4Int(v, OP_OpenRead, iCsr, (int)iRoot, iDb, 1);
153482 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
153485 sqlite3VdbeAddOp2(v, OP_Count, iCsr, AggInfoFuncReg(pAggInfo,0));
153486 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
153516 sqlite3VdbeAddOp2(v, OP_Integer, 0, regAcc);
153556 if( regAcc ) sqlite3VdbeAddOp2(v, OP_Integer, 1, regAcc);
153558 sqlite3WhereMinMaxOptEarlyOut(v, pWInfo);
153570 sqlite3VdbeResolveLabel(v, addrEnd);
153588 sqlite3VdbeResolveLabel(v, iEnd);
154196 Vdbe *v;
154217 v = sqlite3GetVdbe(pParse);
154218 if( v==0 ) goto triggerfinish_cleanup;
154229 sqlite3VdbeAddParseSchemaOp(v, iDb,
154514 Vdbe *v;
154537 if( (v = sqlite3GetVdbe(pParse))!=0 ){
154543 sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger->zName, 0);
154874 Vdbe *v = pParse->pVdbe;
154882 assert( v!=0 );
154937 sqlite3VdbeAddOp1(v, OP_RealAffinity, reg+i);
154940 sqlite3VdbeAddOp3(v, OP_MakeRecord, reg, i, reg+i);
154941 sqlite3VdbeAddOp2(v, OP_NewRowid, pReturning->iRetCur, reg+i+1);
154942 sqlite3VdbeAddOp3(v, OP_Insert, pReturning->iRetCur, reg+i, reg+i+1);
154962 Vdbe *v = pParse->pVdbe;
154967 assert( v!=0 );
154987 sqlite3VdbeAddOp4(v, OP_Trace, 0x7fffffff, 1, 0,
155001 sqlite3VdbeAddOp0(v, OP_ResetCount);
155012 sqlite3VdbeAddOp0(v, OP_ResetCount);
155020 sqlite3VdbeAddOp0(v, OP_ResetCount);
155086 Vdbe *v; /* Temporary VM */
155124 v = sqlite3GetVdbe(&sSubParse);
155125 if( v ){
155126 VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",
155136 sqlite3VdbeChangeP4(v, -1,
155161 sqlite3VdbeResolveLabel(v, iEndTrigger);
155163 sqlite3VdbeAddOp0(v, OP_Halt);
155164 VdbeComment((v, "End: %s.%s", pTrigger->zName, onErrorText(orconf)));
155169 pProgram->aOp = sqlite3VdbeTakeOpArray(v, &pProgram->nOp, &pTop->nMaxArg);
155176 sqlite3VdbeDelete(v);
155235 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
155245 sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
155248 (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
155255 sqlite3VdbeChangeP5(v, (u16)bRecursive);
155470 SQLITE_PRIVATE void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i, int iReg){
155477 u8 enc = ENC(sqlite3VdbeDb(v));
155479 VdbeComment((v, "%s.%s", pTab->zName, pCol->zCnName));
155481 sqlite3ValueFromExpr(sqlite3VdbeDb(v),
155485 sqlite3VdbeAppendP4(v, pValue, P4_MEM);
155490 sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
155708 Vdbe *v; /* The virtual database engine */
155866 v = sqlite3GetVdbe(pParse);
155867 if( v==0 ) goto update_cleanup;
156006 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
156076 sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
156080 sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid);
156082 addrOpen = sqlite3VdbeAddOp3(v, OP_OpenEphemeral, iEph, 0, regRowSet);
156093 if( pPk ) sqlite3VdbeAddOp3(v, OP_Null, 0, iPk, iPk+nPk-1);
156094 addrOpen = sqlite3VdbeAddOp2(v, OP_OpenEphemeral, iEph, nEphCol);
156099 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
156182 sqlite3VdbeAddOp2(v, OP_Rowid, iDataCur, regOldRowid);
156185 sqlite3VdbeAddOp3(v, OP_Insert, iEph, regRowSet, regOldRowid);
156187 if( ALWAYS(addrOpen) ) sqlite3VdbeChangeToNoop(v, addrOpen);
156197 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur,
156201 if( addrOpen ) sqlite3VdbeChangeToNoop(v, addrOpen);
156205 sqlite3VdbeAddOp4(v, OP_MakeRecord, iPk, nPk, regKey,
156207 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iEph, regKey, iPk, nPk);
156229 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
156234 sqlite3VdbeJumpHereOrPopInst(v, addrOnce);
156247 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelBreak, regKey,nKey);
156248 VdbeCoverage(v);
156253 sqlite3VdbeAddOp2(v, OP_IsNull, pPk ? regKey : regOldRowid, labelBreak);
156254 VdbeCoverageIf(v, pPk==0);
156255 VdbeCoverageIf(v, pPk!=0);
156258 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
156259 addrTop = sqlite3VdbeCurrentAddr(v);
156264 sqlite3VdbeAddOp3(v, OP_Column, iEph, i, iPk+i);
156267 v, OP_NotFound, iDataCur, labelContinue, iPk, nPk
156268 ); VdbeCoverage(v);
156270 sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
156272 v, OP_NotExists, iDataCur, labelContinue, regOldRowid
156273 ); VdbeCoverage(v);
156277 sqlite3VdbeAddOp2(v, OP_RowData, iEph, regKey);
156278 sqlite3VdbeAddOp4Int(v, OP_NotFound, iDataCur, labelContinue, regKey,0);
156279 VdbeCoverage(v);
156282 sqlite3VdbeAddOp2(v, OP_Rewind, iEph, labelBreak); VdbeCoverage(v);
156284 addrTop = sqlite3VdbeAddOp2(v, OP_Rowid, iEph, regOldRowid);
156285 VdbeCoverage(v);
156286 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue, regOldRowid);
156287 VdbeCoverage(v);
156301 sqlite3VdbeAddOp3(v, OP_Column, iEph, iRowidExpr, regNewRowid);
156303 sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid); VdbeCoverage(v);
156321 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
156323 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
156328 if( isView ) sqlite3VdbeAddOp2(v, OP_Null, 0, regOldRowid);
156330 sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
156352 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
156361 sqlite3VdbeAddOp3(v, OP_Column, iEph, nOff+j, k);
156373 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
156376 sqlite3VdbeAddOp2(v, OP_Null, 0, k);
156392 sqlite3TableAffinity(v, pTab, regNew);
156404 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
156405 VdbeCoverage(v);
156407 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
156408 VdbeCoverage(v);
156424 sqlite3ExprCodeGetColumnOfTable(v, pTab, iDataCur, i, k);
156449 sqlite3VdbeAddOp4Int(v, OP_NotFound,iDataCur,labelContinue,regKey,nKey);
156451 sqlite3VdbeAddOp3(v, OP_NotExists, iDataCur, labelContinue,regOldRowid);
156453 VdbeCoverage(v);
156470 sqlite3VdbeAddOp1(v, OP_FinishSeek, iDataCur);
156484 sqlite3VdbeAddOp3(v, OP_Delete, iDataCur,
156490 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
156493 sqlite3VdbeAppendP4(v, pTab, P4_TABLE);
156497 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, 0);
156523 sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
156537 sqlite3VdbeResolveLabel(v, labelContinue);
156540 sqlite3VdbeResolveLabel(v, labelContinue);
156541 sqlite3VdbeAddOp2(v, OP_Next, iEph, addrTop); VdbeCoverage(v);
156543 sqlite3VdbeResolveLabel(v, labelBreak);
156558 sqlite3CodeChangeCount(v, regRowCount, "rows updated");
156615 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
156633 assert( v );
156635 addr= sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, nArg);
156693 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, i, regArg+2+i);
156694 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG);/* For sqlite3_vtab_nochange() */
156698 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg);
156702 sqlite3VdbeAddOp2(v, OP_Rowid, iCsr, regArg+1);
156711 sqlite3VdbeAddOp3(v, OP_VColumn, iCsr, iPk, regArg);
156712 sqlite3VdbeAddOp2(v, OP_SCopy, regArg+2+iPk, regArg+1);
156723 sqlite3VdbeChangeToNoop(v, addr);
156724 sqlite3VdbeAddOp1(v, OP_Close, iCsr);
156729 sqlite3VdbeAddOp3(v, OP_MakeRecord, regArg, nArg, regRec);
156733 sqlite3VdbeChangeP5(v, OPFLAG_NOCHNG_MAGIC);
156735 sqlite3VdbeAddOp2(v, OP_NewRowid, ephemTab, regRowid);
156736 sqlite3VdbeAddOp3(v, OP_Insert, ephemTab, regRec, regRowid);
156748 addr = sqlite3VdbeAddOp1(v, OP_Rewind, ephemTab); VdbeCoverage(v);
156753 sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i, regArg+i);
156757 sqlite3VdbeAddOp4(v, OP_VUpdate, 0, nArg, regArg, pVTab, P4_VTAB);
156758 sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
156764 sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr+1); VdbeCoverage(v);
156765 sqlite3VdbeJumpHere(v, addr);
156766 sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
157048 Vdbe *v = pParse->pVdbe;
157055 assert( v!=0 );
157059 VdbeNoopComment((v, "Begin DO UPDATE of UPSERT"));
157063 sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid);
157064 sqlite3VdbeAddOp3(v, OP_SeekRowid, iDataCur, 0, regRowid);
157065 VdbeCoverage(v);
157076 sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i);
157077 VdbeComment((v, "%s.%s", pIdx->zName,
157080 sqlite3VdbeVerifyAbortable(v, OE_Abort);
157081 i = sqlite3VdbeAddOp4Int(v, OP_Found, iDataCur, 0, iPk, nPk);
157082 VdbeCoverage(v);
157083 sqlite3VdbeAddOp4(v, OP_Halt, SQLITE_CORRUPT, OE_Abort, 0,
157086 sqlite3VdbeJumpHere(v, i);
157095 sqlite3VdbeAddOp1(v, OP_RealAffinity, pTop->regData+i);
157100 VdbeNoopComment((v, "End DO UPDATE of UPSERT"));
157212 Vdbe *v = sqlite3GetVdbe(pParse);
157214 if( v==0 ) goto build_vacuum_end;
157238 sqlite3VdbeAddOp2(v, OP_Vacuum, iDb, iIntoReg);
157239 sqlite3VdbeUsesBtree(v, iDb);
157995 Vdbe *v;
158025 v = sqlite3GetVdbe(pParse);
158028 sqlite3VdbeAddOp0(v, OP_Expire);
158030 sqlite3VdbeAddParseSchemaOp(v, iDb, zWhere, 0);
158034 sqlite3VdbeLoadString(v, iReg, pTab->zName);
158035 sqlite3VdbeAddOp2(v, OP_VCreate, iDb, iReg);
158258 ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
159484 # define sqlite3WhereExplainOneScan(u,v,w,x) 0
159485 # define sqlite3WhereExplainBloomFilter(u,v,w) 0
159486 # define sqlite3WhereAddExplainText(u,v,w,x,y)
159490 Vdbe *v, /* Vdbe to add scanstatus entry to */
159500 Vdbe *v, /* Prepared statement under construction */
159832 Vdbe *v = pParse->pVdbe;
159833 int addr = sqlite3VdbeCurrentAddr(v);
159835 v, OP_Explain, addr, pParse->addrExplain, pLevel->pWLoop->rRun
159860 Vdbe *v = pParse->pVdbe; /* VM being constructed */
159888 ret = sqlite3VdbeAddOp4(v, OP_Explain, sqlite3VdbeCurrentAddr(v),
159891 sqlite3VdbeScanStatus(v, sqlite3VdbeCurrentAddr(v)-1, 0, 0, 0, 0);
159907 Vdbe *v, /* Vdbe to add scanstatus entry to */
159912 if( IS_STMT_SCANSTATUS( sqlite3VdbeDb(v) ) ){
159925 v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj
159930 sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iTabCur);
159933 sqlite3VdbeScanStatusRange(v, addrExplain, -1, pLvl->iIdxCur);
159940 pOp = sqlite3VdbeGetOp(v, addr-1);
159941 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->opcode==OP_InitCoroutine );
159942 assert( sqlite3VdbeDb(v)->mallocFailed || pOp->p2>addr );
159943 sqlite3VdbeScanStatusRange(v, addrExplain, addr, pOp->p2-1);
160031 Vdbe *v = pParse->pVdbe;
160036 assert( v!=0 );
160053 sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
160133 ** SELECT * FROM t1 WHERE (a,b,c,d,e) IN (SELECT v,w,x,y,z FROM t2)
160252 Vdbe *v = pParse->pVdbe;
160304 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
160305 VdbeCoverageIf(v, bRev);
160306 VdbeCoverageIf(v, !bRev);
160331 pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iOut);
160334 pIn->addrInTop = sqlite3VdbeAddOp3(v,OP_Column,iTab, iCol, iOut);
160336 sqlite3VdbeAddOp1(v, OP_IsNull, iOut); VdbeCoverage(v);
160358 sqlite3VdbeAddOp3(v, OP_SeekHit, pLevel->iIdxCur, 0, iEq);
160481 Vdbe *v = pParse->pVdbe; /* The vm under construction */
160509 sqlite3VdbeAddOp3(v, OP_Null, 0, regBase, regBase+nSkip-1);
160510 sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur);
160511 VdbeCoverageIf(v, bRev==0);
160512 VdbeCoverageIf(v, bRev!=0);
160513 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
160514 j = sqlite3VdbeAddOp0(v, OP_Goto);
160516 pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT),
160518 VdbeCoverageIf(v, bRev==0);
160519 VdbeCoverageIf(v, bRev!=0);
160520 sqlite3VdbeJumpHere(v, j);
160522 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, j, regBase+j);
160524 VdbeComment((v, "%s", explainIndexColumnName(pIdx, j)));
160545 sqlite3VdbeAddOp2(v, OP_Copy, r1, regBase+j);
160559 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk);
160560 VdbeCoverage(v);
160596 Vdbe *v, /* prepared statement under construction */
160603 pOp = sqlite3VdbeGetLastOp(v);
160734 Vdbe *v = pParse->pVdbe;
160821 sqlite3VdbeAddOp4(v, OP_CursorHint,
160863 Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */
160869 sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
160886 sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY);
160905 Vdbe *v = pParse->pVdbe;
160909 sqlite3VdbeAddOp3(v, OP_Copy, iSelect, iReg, nReg-1);
161047 Vdbe *v, /* Prepared statement under construction */
161077 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",
161119 sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin);
161120 VdbeComment((v, "init LEFT JOIN match flag"));
161138 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSubq->addrFillSub);
161139 pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk);
161140 VdbeCoverage(v);
161141 VdbeComment((v, "next row of %s", pTabItem->pSTab->zName));
161165 sqlite3VdbeAddOp3(v, OP_VInitIn, iTab, iTarget, iCache);
161179 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWInfo->pSelect->iOffset);
161180 VdbeComment((v,"Zero OFFSET counter"));
161184 sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg);
161185 sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1);
161189 sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg,
161192 VdbeCoverage(v);
161199 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
161223 pOp = sqlite3VdbeGetOp(v, pLevel->u.in.aInLoop[iIn].addrInTop);
161228 sqlite3VdbeAddOp3(v, pOp->opcode, pOp->p1, pOp->p2, pOp->p3);
161290 sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt);
161291 VdbeCoverage(v);
161292 sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt,
161294 VdbeCoverage(v);
161297 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg);
161298 VdbeCoverage(v);
161361 sqlite3VdbeAddOp3(v, op, iCur, addrBrk, r1);
161362 VdbeComment((v, "pk"));
161363 VdbeCoverageIf(v, pX->op==TK_GT);
161364 VdbeCoverageIf(v, pX->op==TK_LE);
161365 VdbeCoverageIf(v, pX->op==TK_LT);
161366 VdbeCoverageIf(v, pX->op==TK_GE);
161369 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt);
161370 VdbeCoverageIf(v, bRev==0);
161371 VdbeCoverageIf(v, bRev!=0);
161393 start = sqlite3VdbeCurrentAddr(v);
161400 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
161401 sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg);
161402 VdbeCoverageIf(v, testOp==OP_Le);
161403 VdbeCoverageIf(v, testOp==OP_Lt);
161404 VdbeCoverageIf(v, testOp==OP_Ge);
161405 VdbeCoverageIf(v, testOp==OP_Gt);
161406 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL);
161500 sqlite3VdbeAddOp2(v, OP_Integer, 1, (int)pLevel->iLikeRepCntr);
161501 VdbeComment((v, "LIKE loop counter"));
161502 pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v);
161538 sqlite3VdbeAddOp2(v, OP_Integer, 0, regBignull);
161556 sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur);
161584 whereLikeOptimizationStringFixup(v, pLevel, pRangeStart);
161588 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
161589 VdbeCoverage(v);
161604 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
161608 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
161619 sqlite3VdbeAddOp2(v, OP_Integer, 1, regBignull);
161620 VdbeComment((v, "NULL-scan pass ctr"));
161623 sqlite3VdbeAddOp4Int(v, OP_Filter, pLevel->regFilter, addrNxt,
161625 VdbeCoverage(v);
161641 addrSeekScan = sqlite3VdbeAddOp1(v, OP_SeekScan,
161644 sqlite3VdbeChangeP5(v, 1);
161645 sqlite3VdbeChangeP2(v, addrSeekScan, sqlite3VdbeCurrentAddr(v)+1);
161648 VdbeCoverage(v);
161650 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
161651 VdbeCoverage(v);
161652 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
161653 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
161654 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT );
161655 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
161656 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
161657 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT );
161664 sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3VdbeCurrentAddr(v)+2);
161666 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase,
161668 VdbeCoverage(v);
161669 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
161670 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
161671 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
161672 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
161686 whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd);
161690 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt);
161691 VdbeCoverage(v);
161709 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq);
161718 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
161724 sqlite3VdbeAddOp2(v, OP_IfNot, regBignull, sqlite3VdbeCurrentAddr(v)+3);
161725 VdbeComment((v, "If NULL-scan 2nd pass"));
161726 VdbeCoverage(v);
161729 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
161730 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
161731 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
161732 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
161733 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
161734 if( addrSeekScan ) sqlite3VdbeJumpHere(v, addrSeekScan);
161742 sqlite3VdbeAddOp2(v, OP_If, regBignull, sqlite3VdbeCurrentAddr(v)+2);
161743 VdbeComment((v, "If NULL-scan 1st pass"));
161744 VdbeCoverage(v);
161746 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase,
161748 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
161749 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
161750 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
161751 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
161755 sqlite3VdbeAddOp3(v, OP_SeekHit, iIdxCur, nEq, nEq);
161770 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j);
161772 sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont,
161773 iRowidReg, pPk->nKeyCol); VdbeCoverage(v);
161920 sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset);
161924 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol);
161929 iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn);
162020 sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain);
162030 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
162031 jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0,
162033 VdbeCoverage(v);
162044 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
162059 jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk);
162060 VdbeCoverage(v);
162063 sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid);
162064 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, regRowset, regRowid,
162066 if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
162075 sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody);
162079 if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1);
162132 sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v));
162133 sqlite3VdbeGoto(v, pLevel->addrBrk);
162134 sqlite3VdbeResolveLabel(v, iLoopBody);
162142 pLevel->p2 = sqlite3VdbeCurrentAddr(v);
162164 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
162165 VdbeCoverageIf(v, bRev==0);
162166 VdbeCoverageIf(v, bRev!=0);
162172 pLevel->addrVisit = sqlite3VdbeCurrentAddr(v);
162248 skipLikeAddr = sqlite3VdbeAddOp1(v, (x&1)?OP_IfNot:OP_If,(int)(x>>1));
162249 VdbeCoverageIf(v, (x&1)==1);
162250 VdbeCoverageIf(v, (x&1)==0);
162256 VdbeNoopComment((v, "WhereTerm[%d] (%p) priority=%d",
162265 if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr);
162310 VdbeModuleComment((v, "begin transitive constraint"));
162335 sqlite3ExprCodeGetColumnOfTable(v, pTab, pLevel->iTabCur, -1, r+1);
162344 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
162347 jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, 0, r+1, nPk);
162348 VdbeCoverage(v);
162349 VdbeComment((v, "match against %s", pTab->zName));
162350 sqlite3VdbeAddOp3(v, OP_MakeRecord, r+1, nPk, r);
162351 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, pRJ->iMatch, r, r+1, nPk);
162352 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pRJ->regBloom, 0, r+1, nPk);
162353 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
162354 sqlite3VdbeJumpHere(v, jmp1);
162362 pLevel->addrFirst = sqlite3VdbeCurrentAddr(v);
162363 sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin);
162364 VdbeComment((v, "record LEFT JOIN hit"));
162378 sqlite3VdbeAddOp2(v, OP_BeginSubrtn, 0, pRJ->regReturn);
162379 pRJ->addrSubrtn = sqlite3VdbeCurrentAddr(v);
162428 Vdbe *v = pParse->pVdbe;
162441 sqlite3VdbeNoJumpsOutsideSubrtn(v, pRJ->addrSubrtn, pRJ->endSubrtn,
162455 v, OP_Null, 0, pSubq->regResult,
162459 sqlite3VdbeAddOp1(v, OP_NullRow, pWInfo->a[k].iTabCur);
162462 sqlite3VdbeAddOp1(v, OP_NullRow, iIdxCur);
162497 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
162506 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
162509 jmp = sqlite3VdbeAddOp4Int(v, OP_Filter, pRJ->regBloom, 0, r, nPk);
162510 VdbeCoverage(v);
162511 sqlite3VdbeAddOp4Int(v, OP_Found, pRJ->iMatch, addrCont, r, nPk);
162512 VdbeCoverage(v);
162513 sqlite3VdbeJumpHere(v, jmp);
162514 sqlite3VdbeAddOp2(v, OP_Gosub, pRJ->regReturn, pRJ->addrSubrtn);
162842 Vdbe *v = pParse->pVdbe;
162843 sqlite3VdbeSetVarmask(v, pRight->iColumn);
162854 sqlite3VdbeChangeP3(v, sqlite3VdbeCurrentAddr(v)-1, 0);
164573 SQLITE_PRIVATE void sqlite3WhereMinMaxOptEarlyOut(Vdbe *v, WhereInfo *pWInfo){
164581 sqlite3VdbeGoto(v, pInner->addrNxt);
164585 sqlite3VdbeGoto(v, pWInfo->iBreak);
165172 Vdbe *v = pParse->pVdbe;
165173 VdbeOp *pOp = sqlite3VdbeGetOp(v, iStart);
165174 int iEnd = sqlite3VdbeCurrentAddr(v);
165445 Vdbe *v; /* Prepared statement under construction */
165472 v = pParse->pVdbe;
165473 assert( v!=0 );
165474 addrInit = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
165629 sqlite3VdbeAddOp2(v, OP_OpenAutoindex, pLevel->iIdxCur, nKeyCol+1);
165631 VdbeComment((v, "for %s", pTable->zName));
165635 sqlite3VdbeAddOp2(v, OP_Blob, 10000, pLevel->regFilter);
165647 addrCounter = sqlite3VdbeAddOp2(v, OP_Integer, 0, 0);
165648 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pSubq->addrFillSub);
165649 addrTop = sqlite3VdbeAddOp1(v, OP_Yield, regYield);
165650 VdbeCoverage(v);
165651 VdbeComment((v, "next row of %s", pSrc->pSTab->zName));
165653 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, pLevel->iTabCur); VdbeCoverage(v);
165665 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0,
165668 sqlite3VdbeScanStatusCounters(v, addrExp, addrExp, sqlite3VdbeCurrentAddr(v));
165669 sqlite3VdbeAddOp2(v, OP_IdxInsert, pLevel->iIdxCur, regRecord);
165670 sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
165671 if( pPartial ) sqlite3VdbeResolveLabel(v, iContinue);
165674 sqlite3VdbeChangeP2(v, addrCounter, regBase+n);
165679 sqlite3VdbeGoto(v, addrTop);
165682 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1); VdbeCoverage(v);
165683 sqlite3VdbeChangeP5(v, SQLITE_STMTSTATUS_AUTOINDEX);
165685 sqlite3VdbeJumpHere(v, addrTop);
165689 sqlite3VdbeJumpHere(v, addrInit);
165690 sqlite3VdbeScanStatusRange(v, addrExp, addrExp, -1);
165729 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
165741 assert( v!=0 );
165745 addrOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
165777 sqlite3VdbeAddOp2(v, OP_Blob, (int)sz, pLevel->regFilter);
165779 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
165791 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, r1);
165792 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, 1);
165803 sqlite3VdbeAddOp4Int(v, OP_FilterAdd, pLevel->regFilter, 0, r1, n);
165806 sqlite3VdbeResolveLabel(v, addrCont);
165807 sqlite3VdbeAddOp2(v, OP_Next, pLevel->iTabCur, addrTop+1);
165808 VdbeCoverage(v);
165809 sqlite3VdbeJumpHere(v, addrTop);
165831 sqlite3VdbeJumpHere(v, addrOnce);
166823 if( pTerm->wtFlags & TERM_VIRTUAL ) zType[0] = 'V';
167723 /* TUNING v----- 10 to bias toward indexed IN */
171112 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
171528 sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB);
171557 sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32);
171562 sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ|bFordelete);
171566 sqlite3VdbeChangeP5(v, bFordelete);
171569 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, pTabItem->iCursor, 0, 0,
171617 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
171626 sqlite3VdbeChangeP5(v, OPFLAG_SEEKEQ);
171628 VdbeComment((v, "%s", pIx->zName));
171640 sqlite3VdbeAddOp4Dup8(v, OP_ColumnsUsed, iIndexCur, 0, 0,
171653 sqlite3VdbeAddOp2(v, OP_Blob, 65536, pRJ->regBloom);
171655 sqlite3VdbeAddOp2(v, OP_Null, 0, pRJ->regReturn);
171659 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, 1);
171664 sqlite3VdbeAppendP4(v, pInfo, P4_KEYINFO);
171668 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pRJ->iMatch, pPk->nKeyCol);
171679 pWInfo->iTop = sqlite3VdbeCurrentAddr(v);
171700 iOnce = sqlite3VdbeAddOp0(v, OP_Once); VdbeCoverage(v);
171704 sqlite3VdbeAddOp2(v, OP_Gosub, pSubq->regReturn, pSubq->addrFillSub);
171705 VdbeComment((v, "materialize %!S", pSrc));
171706 if( iOnce ) sqlite3VdbeJumpHere(v, iOnce);
171722 pLevel->addrBody = sqlite3VdbeCurrentAddr(v);
171723 notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady);
171726 sqlite3WhereAddScanStatus(v, pTabList, pLevel, addrExplain);
171731 VdbeModuleComment((v, "Begin WHERE-core"));
171732 pWInfo->iEndWhere = sqlite3VdbeCurrentAddr(v);
171776 Vdbe *v = pParse->pVdbe;
171782 int iEnd = sqlite3VdbeCurrentAddr(v);
171787 VdbeModuleComment((v, "End WHERE-core"));
171795 sqlite3VdbeResolveLabel(v, pLevel->addrCont);
171797 pRJ->endSubrtn = sqlite3VdbeCurrentAddr(v);
171798 sqlite3VdbeAddOp3(v, OP_Return, pRJ->regReturn, pRJ->addrSubrtn, 1);
171799 VdbeCoverage(v);
171818 sqlite3VdbeAddOp3(v, OP_Column, pLevel->iIdxCur, j, r1+j);
171822 addrSeek = sqlite3VdbeAddOp4Int(v, op, pLevel->iIdxCur, 0, r1, n);
171823 VdbeCoverageIf(v, op==OP_SeekLT);
171824 VdbeCoverageIf(v, op==OP_SeekGT);
171825 sqlite3VdbeAddOp2(v, OP_Goto, 1, pLevel->p2);
171829 if( pLevel->addrCont ) sqlite3VdbeResolveLabel(v, pLevel->addrCont);
171830 sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
171831 sqlite3VdbeChangeP5(v, pLevel->p5);
171832 VdbeCoverage(v);
171833 VdbeCoverageIf(v, pLevel->op==OP_Next);
171834 VdbeCoverageIf(v, pLevel->op==OP_Prev);
171835 VdbeCoverageIf(v, pLevel->op==OP_VNext);
171837 sqlite3VdbeResolveLabel(v, pLevel->addrBignull);
171838 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, pLevel->regBignull, pLevel->p2-1);
171839 VdbeCoverage(v);
171842 if( addrSeek ) sqlite3VdbeJumpHere(v, addrSeek);
171845 sqlite3VdbeResolveLabel(v, pLevel->addrCont);
171850 sqlite3VdbeResolveLabel(v, pLevel->addrNxt);
171852 assert( sqlite3VdbeGetOp(v, pIn->addrInTop+1)->opcode==OP_IsNull
171854 sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
171869 sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur,
171870 sqlite3VdbeCurrentAddr(v) + 2 + bEarlyOut);
171871 VdbeCoverage(v);
171874 sqlite3VdbeAddOp4Int(v, OP_IfNoHope, pLevel->iIdxCur,
171875 sqlite3VdbeCurrentAddr(v)+2,
171877 VdbeCoverage(v);
171882 sqlite3VdbeJumpHere(v, pIn->addrInTop+1);
171885 sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);
171886 VdbeCoverage(v);
171887 VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Prev);
171888 VdbeCoverageIf(v, pIn->eEndLoopOp==OP_Next);
171890 sqlite3VdbeJumpHere(v, pIn->addrInTop-1);
171893 sqlite3VdbeResolveLabel(v, pLevel->addrBrk);
171895 sqlite3VdbeAddOp3(v, OP_Return, pLevel->pRJ->regReturn, 0, 1);
171896 VdbeCoverage(v);
171899 sqlite3VdbeGoto(v, pLevel->addrSkip);
171900 VdbeComment((v, "next skip-scan on %s", pLoop->u.btree.pIndex->zName));
171901 sqlite3VdbeJumpHere(v, pLevel->addrSkip);
171902 sqlite3VdbeJumpHere(v, pLevel->addrSkip-2);
171906 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, (int)(pLevel->iLikeRepCntr>>1),
171908 VdbeCoverage(v);
171913 addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); VdbeCoverage(v);
171924 sqlite3VdbeAddOp3(v, OP_Null, 0, n, n+m-1);
171926 sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iTabCur);
171934 sqlite3VdbeAddOp3(v, OP_ReopenIdx, pLevel->iIdxCur, pIx->tnum, iDb);
171937 sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur);
171940 sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst);
171942 sqlite3VdbeGoto(v, pLevel->addrFirst);
171944 sqlite3VdbeJumpHere(v, addr);
171946 VdbeModuleComment((v, "End WHERE-loop%d: %s", i,
172030 pOp = sqlite3VdbeGetOp(v, k - 1);
172035 pOp = sqlite3VdbeGetOp(v, k);
172111 sqlite3VdbeResolveLabel(v, pWInfo->iBreak);
173087 Vdbe *v = sqlite3GetVdbe(pParse);
173177 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
173516 Vdbe *v;
173521 v = sqlite3GetVdbe(pParse);
173523 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pMWin->iEphCsr, nEphExpr);
173524 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+1, pMWin->iEphCsr);
173525 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+2, pMWin->iEphCsr);
173526 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->iEphCsr+3, pMWin->iEphCsr);
173534 sqlite3VdbeAddOp3(v, OP_Null, 0, pMWin->regPart, pMWin->regPart+nExpr-1);
173538 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regOne);
173544 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
173545 sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
173546 sqlite3VdbeAddOp2(v, OP_OpenDup, pMWin->csrApp, pMWin->iEphCsr);
173572 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, pWin->csrApp, 2);
173573 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
173574 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
173582 sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
173586 sqlite3VdbeAddOp2(v, OP_OpenDup, pWin->csrApp, pMWin->iEphCsr);
173613 Vdbe *v = sqlite3GetVdbe(pParse);
173616 sqlite3VdbeAddOp2(v, OP_Integer, 0, regZero);
173619 sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
173620 sqlite3VdbeAddOp3(v, OP_Ge, regString, sqlite3VdbeCurrentAddr(v)+2, reg);
173621 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC|SQLITE_JUMPIFNULL);
173622 VdbeCoverage(v);
173624 VdbeCoverageIf(v, eCond==3);
173625 VdbeCoverageIf(v, eCond==4);
173627 sqlite3VdbeAddOp2(v, OP_MustBeInt, reg, sqlite3VdbeCurrentAddr(v)+2);
173628 VdbeCoverage(v);
173630 VdbeCoverageIf(v, eCond==0);
173631 VdbeCoverageIf(v, eCond==1);
173632 VdbeCoverageIf(v, eCond==2);
173634 sqlite3VdbeAddOp3(v, aOp[eCond], regZero, sqlite3VdbeCurrentAddr(v)+2, reg);
173635 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC);
173636 VdbeCoverageNeverNullIf(v, eCond==0); /* NULL case captured by */
173637 VdbeCoverageNeverNullIf(v, eCond==1); /* the OP_MustBeInt */
173638 VdbeCoverageNeverNullIf(v, eCond==2);
173639 VdbeCoverageNeverNullIf(v, eCond==3); /* NULL case caught by */
173640 VdbeCoverageNeverNullIf(v, eCond==4); /* the OP_Ge */
173642 sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_ERROR, OE_Abort);
173643 sqlite3VdbeAppendP4(v, (void*)azErr[eCond], P4_STATIC);
173751 Vdbe *v = sqlite3GetVdbe(p->pParse);
173756 sqlite3VdbeAddOp3(v, OP_Column, csr, iColOff+i, reg+i);
173788 Vdbe *v = sqlite3GetVdbe(pParse);
173805 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+i, reg+i);
173807 sqlite3VdbeAddOp3(v, OP_Column, pMWin->iEphCsr, pWin->iArgCol+i, reg+i);
173818 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol+nArg,regTmp);
173819 addrIf = sqlite3VdbeAddOp3(v, OP_IfNot, regTmp, 0, 1);
173820 VdbeCoverage(v);
173828 int addrIsNull = sqlite3VdbeAddOp1(v, OP_IsNull, regArg);
173829 VdbeCoverage(v);
173831 sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1, 1);
173832 sqlite3VdbeAddOp2(v, OP_SCopy, regArg, pWin->regApp);
173833 sqlite3VdbeAddOp3(v, OP_MakeRecord, pWin->regApp, 2, pWin->regApp+2);
173834 sqlite3VdbeAddOp2(v, OP_IdxInsert, pWin->csrApp, pWin->regApp+2);
173836 sqlite3VdbeAddOp4Int(v, OP_SeekGE, pWin->csrApp, 0, regArg, 1);
173837 VdbeCoverageNeverTaken(v);
173838 sqlite3VdbeAddOp1(v, OP_Delete, pWin->csrApp);
173839 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
173841 sqlite3VdbeJumpHere(v, addrIsNull);
173848 sqlite3VdbeAddOp2(v, OP_AddImm, pWin->regApp+1-bInverse, 1);
173851 int iOp = sqlite3VdbeCurrentAddr(v);
173859 for(iEnd=sqlite3VdbeCurrentAddr(v); iOp<iEnd; iOp++){
173860 VdbeOp *pOp = sqlite3VdbeGetOp(v, iOp);
173871 sqlite3VdbeAddOp4(v, OP_CollSeq, 0,0,0, (const char*)pColl, P4_COLLSEQ);
173873 sqlite3VdbeAddOp3(v, bInverse? OP_AggInverse : OP_AggStep,
173875 sqlite3VdbeAppendP4(v, pFunc, P4_FUNCDEF);
173876 sqlite3VdbeChangeP5(v, (u16)nArg);
173882 if( addrIf ) sqlite3VdbeJumpHere(v, addrIf);
173902 Vdbe *v = sqlite3GetVdbe(pParse);
173910 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
173911 sqlite3VdbeAddOp1(v, OP_Last, pWin->csrApp);
173912 VdbeCoverage(v);
173913 sqlite3VdbeAddOp3(v, OP_Column, pWin->csrApp, 0, pWin->regResult);
173914 sqlite3VdbeJumpHere(v, sqlite3VdbeCurrentAddr(v)-2);
173920 sqlite3VdbeAddOp2(v, OP_AggFinal, pWin->regAccum, nArg);
173921 sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF);
173922 sqlite3VdbeAddOp2(v, OP_Copy, pWin->regAccum, pWin->regResult);
173923 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
173925 sqlite3VdbeAddOp3(v, OP_AggValue,pWin->regAccum,nArg,pWin->regResult);
173926 sqlite3VdbeAppendP4(v, pWin->pWFunc, P4_FUNCDEF);
173942 Vdbe *v = p->pVdbe;
173955 VdbeModuleComment((v, "windowFullScan begin"));
173971 sqlite3VdbeAddOp2(v, OP_Rowid, pMWin->iEphCsr, regCRowid);
173975 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
173978 sqlite3VdbeAddOp3(v, OP_SeekGE, csr, lblBrk, pMWin->regStartRowid);
173979 VdbeCoverage(v);
173980 addrNext = sqlite3VdbeCurrentAddr(v);
173981 sqlite3VdbeAddOp2(v, OP_Rowid, csr, regRowid);
173982 sqlite3VdbeAddOp3(v, OP_Gt, pMWin->regEndRowid, lblBrk, regRowid);
173983 VdbeCoverageNeverNull(v);
173986 sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, lblNext, regRowid);
173987 VdbeCoverageNeverNull(v);
173997 addrEq = sqlite3VdbeAddOp3(v, OP_Eq, regCRowid, 0, regRowid);
173998 VdbeCoverageNeverNull(v);
174002 sqlite3VdbeAddOp3(v, OP_Compare, regPeer, regCPeer, nPeer);
174003 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
174004 addr = sqlite3VdbeCurrentAddr(v)+1;
174005 sqlite3VdbeAddOp3(v, OP_Jump, addr, lblNext, addr);
174006 VdbeCoverageEqNe(v);
174008 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblNext);
174010 if( addrEq ) sqlite3VdbeJumpHere(v, addrEq);
174015 sqlite3VdbeResolveLabel(v, lblNext);
174016 sqlite3VdbeAddOp2(v, OP_Next, csr, addrNext);
174017 VdbeCoverage(v);
174018 sqlite3VdbeJumpHere(v, addrNext-1);
174019 sqlite3VdbeJumpHere(v, addrNext+1);
174028 VdbeModuleComment((v, "windowFullScan end"));
174046 Vdbe *v = p->pVdbe;
174063 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
174066 sqlite3VdbeAddOp3(v, OP_Column,pMWin->iEphCsr,pWin->iArgCol+1,tmpReg);
174069 sqlite3VdbeAddOp2(v, OP_Integer, 1, tmpReg);
174071 sqlite3VdbeAddOp3(v, OP_Add, tmpReg, pWin->regApp, tmpReg);
174072 sqlite3VdbeAddOp3(v, OP_Gt, pWin->regApp+1, lbl, tmpReg);
174073 VdbeCoverageNeverNull(v);
174074 sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, 0, tmpReg);
174075 VdbeCoverageNeverTaken(v);
174076 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
174077 sqlite3VdbeResolveLabel(v, lbl);
174088 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regResult);
174090 sqlite3VdbeAddOp3(v, OP_Column, iEph,pWin->iArgCol+2,pWin->regResult);
174092 sqlite3VdbeAddOp2(v, OP_Rowid, iEph, tmpReg);
174095 sqlite3VdbeAddOp2(v, OP_AddImm, tmpReg, val);
174099 sqlite3VdbeAddOp3(v, OP_Column, iEph, pWin->iArgCol+1, tmpReg2);
174100 sqlite3VdbeAddOp3(v, op, tmpReg2, tmpReg, tmpReg);
174104 sqlite3VdbeAddOp3(v, OP_SeekRowid, csr, lbl, tmpReg);
174105 VdbeCoverage(v);
174106 sqlite3VdbeAddOp3(v, OP_Column, csr, pWin->iArgCol, pWin->regResult);
174107 sqlite3VdbeResolveLabel(v, lbl);
174112 sqlite3VdbeAddOp2(v, OP_Gosub, p->regGosub, p->addrGosub);
174122 Vdbe *v = sqlite3GetVdbe(pParse);
174129 sqlite3VdbeAddOp2(v, OP_Null, 0, pWin->regAccum);
174133 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp);
174134 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
174139 sqlite3VdbeAddOp1(v, OP_ResetSorter, pWin->csrApp);
174140 sqlite3VdbeAddOp2(v, OP_Integer, 0, pWin->regApp+1);
174186 Vdbe *v = sqlite3GetVdbe(pParse);
174190 sqlite3VdbeAddOp3(v, OP_Compare, regOld, regNew, nVal);
174191 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
174192 sqlite3VdbeAddOp3(v, OP_Jump,
174193 sqlite3VdbeCurrentAddr(v)+1, addr, sqlite3VdbeCurrentAddr(v)+1
174195 VdbeCoverageEqNe(v);
174196 sqlite3VdbeAddOp3(v, OP_Copy, regNew, regOld, nVal-1);
174198 sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
174234 Vdbe *v = sqlite3GetVdbe(pParse);
174259 VdbeModuleComment((v, "CodeRangeTest: if( R%d %s R%d %s R%d ) goto lbl",
174285 int addr = sqlite3VdbeAddOp1(v, OP_NotNull, reg1); VdbeCoverage(v);
174288 sqlite3VdbeAddOp2(v, OP_Goto, 0, lbl);
174291 sqlite3VdbeAddOp2(v, OP_NotNull, reg2, lbl);
174292 VdbeCoverage(v);
174295 sqlite3VdbeAddOp2(v, OP_IsNull, reg2, lbl);
174296 VdbeCoverage(v);
174300 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrDone);
174303 sqlite3VdbeJumpHere(v, addr);
174304 sqlite3VdbeAddOp2(v, OP_IsNull, reg2,
174306 VdbeCoverage(v);
174322 sqlite3VdbeAddOp4(v, OP_String8, 0, regString, 0, "", P4_STATIC);
174323 addrGe = sqlite3VdbeAddOp3(v, OP_Ge, regString, 0, reg1);
174324 VdbeCoverage(v);
174326 sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
174328 sqlite3VdbeAddOp3(v, arith, regVal, reg1, reg1);
174329 sqlite3VdbeJumpHere(v, addrGe);
174334 sqlite3VdbeAddOp3(v, op, reg2, lbl, reg1); VdbeCoverage(v);
174336 sqlite3VdbeAppendP4(v, (void*)pColl, P4_COLLSEQ);
174337 sqlite3VdbeChangeP5(v, SQLITE_NULLEQ);
174338 sqlite3VdbeResolveLabel(v, addrDone);
174341 testcase(op==OP_Ge); VdbeCoverageIf(v, op==OP_Ge);
174342 testcase(op==OP_Lt); VdbeCoverageIf(v, op==OP_Lt);
174343 testcase(op==OP_Le); VdbeCoverageIf(v, op==OP_Le);
174344 testcase(op==OP_Gt); VdbeCoverageIf(v, op==OP_Gt);
174348 VdbeModuleComment((v, "CodeRangeTest: end"));
174367 Vdbe *v = p->pVdbe;
174383 addrNextRange = sqlite3VdbeCurrentAddr(v);
174401 sqlite3VdbeAddOp3(v, OP_IfPos, regCountdown, lblDone, 1);
174402 VdbeCoverage(v);
174409 addrContinue = sqlite3VdbeCurrentAddr(v);
174423 sqlite3VdbeAddOp2(v, OP_Rowid, p->start.csr, regRowid1);
174424 sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid2);
174425 sqlite3VdbeAddOp3(v, OP_Ge, regRowid2, lblDone, regRowid1);
174426 VdbeCoverage(v);
174428 sqlite3VdbeAddOp2(v, OP_Rowid, p->end.csr, regRowid1);
174429 sqlite3VdbeAddOp3(v, OP_Ge, p->regRowid, lblDone, regRowid1);
174430 VdbeCoverageNeverNull(v);
174449 sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regStartRowid, 1);
174461 sqlite3VdbeAddOp2(v, OP_AddImm, pMWin->regEndRowid, 1);
174469 sqlite3VdbeAddOp1(v, OP_Delete, csr);
174470 sqlite3VdbeChangeP5(v, OPFLAG_SAVEPOSITION);
174474 sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+2);
174475 VdbeCoverage(v);
174476 ret = sqlite3VdbeAddOp0(v, OP_Goto);
174478 sqlite3VdbeAddOp2(v, OP_Next, csr, sqlite3VdbeCurrentAddr(v)+1+bPeer);
174479 VdbeCoverage(v);
174481 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblDone);
174494 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNextRange);
174496 sqlite3VdbeResolveLabel(v, lblDone);
174917 Vdbe *v = sqlite3GetVdbe(pParse);
174953 s.pVdbe = v;
175028 sqlite3VdbeAddOp3(v, OP_Column, csrInput, iInput, regNew+iInput);
175030 sqlite3VdbeAddOp3(v, OP_MakeRecord, regNew, nInput, regRecord);
175045 addr = sqlite3VdbeAddOp3(v, OP_Compare, regNewPart, pMWin->regPart, nPart);
175046 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
175047 sqlite3VdbeAddOp3(v, OP_Jump, addr+2, addr+4, addr+2);
175048 VdbeCoverageEqNe(v);
175049 addrGosubFlush = sqlite3VdbeAddOp1(v, OP_Gosub, regFlushPart);
175050 VdbeComment((v, "call flush_partition"));
175051 sqlite3VdbeAddOp3(v, OP_Copy, regNewPart, pMWin->regPart, nPart-1);
175055 sqlite3VdbeAddOp2(v, OP_NewRowid, csrWrite, s.regRowid);
175056 sqlite3VdbeAddOp3(v, OP_Insert, csrWrite, regRecord, s.regRowid);
175057 addrNe = sqlite3VdbeAddOp3(v, OP_Ne, pMWin->regOne, 0, s.regRowid);
175058 VdbeCoverageNeverNull(v);
175074 int addrGe = sqlite3VdbeAddOp3(v, op, regStart, 0, regEnd);
175075 VdbeCoverageNeverNullIf(v, op==OP_Ge); /* NeverNull because bound <expr> */
175076 VdbeCoverageNeverNullIf(v, op==OP_Le); /* values previously checked */
175078 sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);
175080 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
175081 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
175082 sqlite3VdbeJumpHere(v, addrGe);
175086 sqlite3VdbeAddOp3(v, OP_Subtract, regStart, regEnd, regStart);
175090 sqlite3VdbeAddOp1(v, OP_Rewind, s.start.csr);
175092 sqlite3VdbeAddOp1(v, OP_Rewind, s.current.csr);
175093 sqlite3VdbeAddOp1(v, OP_Rewind, s.end.csr);
175095 sqlite3VdbeAddOp3(v, OP_Copy, regNewPeer, regPeer, pOrderBy->nExpr-1);
175096 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.start.reg, pOrderBy->nExpr-1);
175097 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.current.reg, pOrderBy->nExpr-1);
175098 sqlite3VdbeAddOp3(v, OP_Copy, regPeer, s.end.reg, pOrderBy->nExpr-1);
175101 sqlite3VdbeAddOp2(v, OP_Goto, 0, lblWhereEnd);
175103 sqlite3VdbeJumpHere(v, addrNe);
175114 int addrNext = sqlite3VdbeCurrentAddr(v);
175118 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrNext);
175119 sqlite3VdbeResolveLabel(v, lbl);
175138 addr = sqlite3VdbeCurrentAddr(v);
175146 sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
175147 sqlite3VdbeResolveLabel(v, lbl);
175151 addr = sqlite3VdbeAddOp3(v, OP_IfPos, regEnd, 0, 1);
175152 VdbeCoverage(v);
175156 if( regEnd ) sqlite3VdbeJumpHere(v, addr);
175162 sqlite3VdbeResolveLabel(v, lblWhereEnd);
175167 addrInteger = sqlite3VdbeAddOp2(v, OP_Integer, 0, regFlushPart);
175168 sqlite3VdbeJumpHere(v, addrGosubFlush);
175172 addrEmpty = sqlite3VdbeAddOp1(v, OP_Rewind, csrWrite);
175173 VdbeCoverage(v);
175186 addrStart = sqlite3VdbeCurrentAddr(v);
175191 addrStart = sqlite3VdbeCurrentAddr(v);
175196 addrStart = sqlite3VdbeCurrentAddr(v);
175200 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
175201 sqlite3VdbeJumpHere(v, addrBreak2);
175202 addrStart = sqlite3VdbeCurrentAddr(v);
175204 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
175205 sqlite3VdbeJumpHere(v, addrBreak1);
175206 sqlite3VdbeJumpHere(v, addrBreak3);
175211 addrStart = sqlite3VdbeCurrentAddr(v);
175214 sqlite3VdbeAddOp2(v, OP_Goto, 0, addrStart);
175215 sqlite3VdbeJumpHere(v, addrBreak);
175217 sqlite3VdbeJumpHere(v, addrEmpty);
175219 sqlite3VdbeAddOp1(v, OP_ResetSorter, s.current.csr);
175222 sqlite3VdbeAddOp2(v, OP_Integer, 1, pMWin->regStartRowid);
175223 sqlite3VdbeAddOp2(v, OP_Integer, 0, pMWin->regEndRowid);
175225 sqlite3VdbeChangeP1(v, addrInteger, sqlite3VdbeCurrentAddr(v));
175226 sqlite3VdbeAddOp1(v, OP_Return, regFlushPart);
181006 'T','E','M','P','O','R','A','R','Y','I','S','N','U','L','L','S','A','V',
181010 'C','L','U','S','I','V','E','X','I','S','T','S','C','O','N','S','T','R',
181012 'G','E','N','E','R','A','T','E','D','E','T','A','C','H','A','V','I','N',
181022 'I','S','T','I','N','C','T','U','P','D','A','T','E','V','A','L','U','E',
181023 'S','V','I','R','T','U','A','L','W','A','Y','S','W','H','E','N','W','H',
181024 'E','R','E','C','U','R','S','I','V','E','A','B','O','R','T','A','F','T',
181033 'I','C','T','O','T','H','E','R','S','O','V','E','R','E','T','U','R','N',
181036 'I','N','G','V','A','C','U','U','M','V','I','E','W','I','N','D','O','W',
183867 ** SQL statements below, as the v-table implementation may be storing
187444 sqlite3_int64 v;
187445 if( z && sqlite3DecOrHexToI64(z, &v)==0 ){
187446 bDflt = v;
189371 SQLITE_PRIVATE int sqlite3Fts3PutVarint(char *p, sqlite_int64 v){
189373 sqlite_uint64 vu = v;
189383 #define GETVARINT_STEP(v, ptr, shift, mask1, mask2, var, ret) \
189384 v = (v & mask1) | ( (*(const unsigned char*)(ptr++)) << shift ); \
189385 if( (v & mask2)==0 ){ var = v; return ret; }
189386 #define GETVARINT_INIT(v, ptr, shift, mask1, mask2, var, ret) \
189387 v = (*ptr++); \
189388 if( (v & mask2)==0 ){ var = v; return ret; }
189390 SQLITE_PRIVATE int sqlite3Fts3GetVarintU(const char *pBuf, sqlite_uint64 *v){
189397 GETVARINT_INIT(a, p, 0, 0x00, 0x80, *v, 1);
189398 GETVARINT_STEP(a, p, 7, 0x7F, 0x4000, *v, 2);
189399 GETVARINT_STEP(a, p, 14, 0x3FFF, 0x200000, *v, 3);
189400 GETVARINT_STEP(a, p, 21, 0x1FFFFF, 0x10000000, *v, 4);
189408 *v = b;
189415 ** The value is stored in *v.
189417 SQLITE_PRIVATE int sqlite3Fts3GetVarint(const char *pBuf, sqlite_int64 *v){
189418 return sqlite3Fts3GetVarintU(pBuf, (sqlite3_uint64*)v);
189425 ** The value is stored in *v.
189430 sqlite_int64 *v
189443 *v = b;
189473 ** Return the number of bytes required to encode v as a varint
189475 SQLITE_PRIVATE int sqlite3Fts3VarintLen(sqlite3_uint64 v){
189479 v >>= 7;
189480 }while( v!=0 );
195552 sqlite3_int64 v = 0;
195554 i += sqlite3Fts3GetVarint(&aDoclist[i], &v);
195573 if( v>1 ){
195580 if( v==0 ){ /* 0x00. Next integer will be a docid. */
195582 }else if( v==1 ){ /* 0x01. Next integer will be a column number. */
195592 iCol = (int)v;
195926 return c==' ' || c=='\t' || c=='\n' || c=='\r' || c=='\v' || c=='\f';
197684 ** Let any sequence of one or more vowels be represented by V and let
197688 ** [C] (VC){m} [V]
198056 case 'v':
204852 int v;
204854 v = atoi(&zVal[9]);
204855 if( v>=24 && v<=p->nPgsz-35 ) p->nNodeSize = v;
204858 v = atoi(&zVal[11]);
204859 if( v>=64 && v<=FTS3_MAX_PENDING_DATA ) p->nMaxPendingData = v;
204865 v = atoi(&zVal[11]);
204866 if( v>=4 && v<=FTS3_MERGE_COUNT && (v&1)==0 ) p->nMergeCount = v;
207618 's'|HIBIT, 't', 'u', 'u'|HIBIT, 'v', 'w',
207715 {976, 140, 1}, {977, 142, 1}, {981, 146, 1},
208751 u32 v;
208752 v = (jsonHexToInt(z[0])<<12)
208756 return v;
209566 }else if( c=='\'' || c=='v' || c=='\n'
210110 case 'v':
210514 u32 v, vlo;
210519 v = jsonHexToInt4(&z[2]);
210520 if( (v & 0xfc00)==0xd800
210526 *piOut = ((v&0x3ff)<<10) + (vlo&0x3ff) + 0x10000;
210529 *piOut = v;
210538 case 'v': { *piOut = '\v'; return 2; }
210819 u32 v = k+sz; /* v is the index of the value */
210820 if( ((pParse->aBlob[v])&0x0f)>JSONB_OBJECT ) return JSON_LOOKUP_ERROR;
210821 n = jsonbPayloadSize(pParse, v, &sz);
210822 if( n==0 || v+n+sz>iEnd ) return JSON_LOOKUP_ERROR;
210824 rc = jsonLookupStep(pParse, v, &zPath[i], j);
210837 JsonParse v; /* BLOB encoding of the value to be inserted */
210845 rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i]);
210847 && jsonBlobMakeEditable(pParse, ix.nBlob+nKey+v.nBlob)
210850 nIns = ix.nBlob + nKey + v.nBlob;
210859 memcpy(&pParse->aBlob[k], v.aBlob, v.nBlob);
210863 jsonParseReset(&v);
210914 JsonParse v;
210917 rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i+1]);
210919 && jsonBlobMakeEditable(pParse, v.nBlob)
210922 jsonBlobEdit(pParse, j, 0, v.aBlob, v.nBlob);
210924 jsonParseReset(&v);
211058 u32 v;
211059 u32 szEscape = jsonUnescapeOneChar(&z[iIn], sz-iIn, &v);
211060 if( v<=0x7f ){
211061 zOut[iOut++] = (char)v;
211062 }else if( v<=0x7ff ){
211064 zOut[iOut++] = (char)(0xc0 | (v>>6));
211065 zOut[iOut++] = 0x80 | (v&0x3f);
211066 }else if( v<0x10000 ){
211068 zOut[iOut++] = 0xe0 | (v>>12);
211069 zOut[iOut++] = 0x80 | ((v>>6)&0x3f);
211070 zOut[iOut++] = 0x80 | (v&0x3f);
211071 }else if( v==JSON_INVALID_CHAR ){
211075 zOut[iOut++] = 0xf0 | (v>>18);
211076 zOut[iOut++] = 0x80 | ((v>>12)&0x3f);
211077 zOut[iOut++] = 0x80 | ((v>>6)&0x3f);
211078 zOut[iOut++] = 0x80 | (v&0x3f);
216441 static RtreeValue rtreeValueDown(sqlite3_value *v){
216442 double d = sqlite3_value_double(v);
216449 static RtreeValue rtreeValueUp(sqlite3_value *v){
216450 double d = sqlite3_value_double(v);
218539 int v = 0;
218546 v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),
218548 if( v==2 ) break;
218549 cnt += v;
218551 if( v!=2 ){
218552 v = pointBeneathLine(x0,y0,GeoX(p1,ii), GeoY(p1,ii),
218555 if( v==2 ){
218557 }else if( ((v+cnt)&1)==0 ){
219751 ** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $
221419 "CREATE TABLE IF NOT EXISTS %s.rbu_state(k INTEGER PRIMARY KEY, v)"
221752 unsigned int v = 0;
221757 v = (v<<6) + c;
221762 return v;
223958 sqlite3_mprintf("SELECT k, v FROM %s.rbu_state", p->zStateDb)
224802 "INSERT OR REPLACE INTO %s.rbu_state(k, v) VALUES "
230608 static void sessionAppendByte(SessionBuffer *p, u8 v, int *pRc){
230610 p->aBuf[p->nBuf++] = v;
230621 static void sessionAppendVarint(SessionBuffer *p, int v, int *pRc){
230623 p->nBuf += sessionVarintPut(&p->aBuf[p->nBuf], v);
231658 sqlite3_int64 v = sessionGetI64(aVal);
231660 sqlite3VdbeMemSetInt64(apOut[i], v);
231663 memcpy(&d, &v, 8);
236123 static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v);
236126 static int sqlite3Fts5PutVarint(unsigned char *p, u64 v);
240268 const char *zSelect = "SELECT k, v FROM %Q.'%q_config'";
252535 # define fts5TestTerm(u,v,w,x,y,z)
257949 pConfig, "config", "k PRIMARY KEY, v", 1, pzErr
259801 /* porter rule condition: (*v*) */
259931 case 'v':
260177 case 'v':
260632 's'|HIBIT, 't', 'u', 'u'|HIBIT, 'v', 'w',
260729 {976, 140, 1}, {977, 142, 1}, {981, 146, 1},
261093 976, 977, 1024, 1064, 1104, 1184, 2048, 2056, 2058, 2103,
261369 static int sqlite3Fts5GetVarint32(const unsigned char *p, u32 *v){
261378 *v = a;
261391 *v = a | b;
261406 *v = a | b;
261424 *v = ((u32)v64) & 0x7FFFFFFF;
261445 ** Return the number of bytes read. The value is stored in *v.
261447 static u8 sqlite3Fts5GetVarint(const unsigned char *p, u64 *v){
261454 *v = a;
261466 *v = a;
261484 *v = a;
261501 *v = a;
261526 *v = ((u64)s)<<32 | a;
261547 *v = ((u64)s)<<32 | a;
261562 *v = ((u64)s)<<32 | a;
261580 *v = ((u64)s)<<32 | a;
261601 *v = ((u64)s)<<32 | a;
261641 static int FTS5_NOINLINE fts5PutVarint64(unsigned char *p, u64 v){
261644 if( v & (((u64)0xff000000)<<32) ){
261645 p[8] = (u8)v;
261646 v >>= 8;
261648 p[i] = (u8)((v & 0x7f) | 0x80);
261649 v >>= 7;
261655 buf[n++] = (u8)((v & 0x7f) | 0x80);
261656 v >>= 7;
261657 }while( v!=0 );
261666 static int sqlite3Fts5PutVarint(unsigned char *p, u64 v){
261667 if( v<=0x7f ){
261668 p[0] = v&0x7f;
261671 if( v<=0x3fff ){
261672 p[0] = ((v>>7)&0x7f)|0x80;
261673 p[1] = v&0x7f;
261676 return fts5PutVarint64(p,v);