Lines Matching refs:op
949 int (*xFileControl)(sqlite3_file*, int op, void *pArg);
1605 SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3*, int op, ...);
5798 unsigned char op; /* Constraint operator */ member
6525 SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);
6544 SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...);
6607 SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
6609 int op,
6732 SQLITE_API int SQLITE_STDCALL sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int reset…
6862 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
7734 SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3*, int op, ...);
9998 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op);
10272 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint);
11926 u8 op; /* Operation performed by this node */ member
12279 u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ member
12657 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ member
12717 u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ member
15051 SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(int op){ in sqlite3StatusValue() argument
15053 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusValue()
15054 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusValue()
15055 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusValue()
15057 return wsdStat.nowValue[op]; in sqlite3StatusValue()
15071 SQLITE_PRIVATE void sqlite3StatusUp(int op, int N){ in sqlite3StatusUp() argument
15073 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusUp()
15074 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusUp()
15075 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusUp()
15077 wsdStat.nowValue[op] += N; in sqlite3StatusUp()
15078 if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){ in sqlite3StatusUp()
15079 wsdStat.mxValue[op] = wsdStat.nowValue[op]; in sqlite3StatusUp()
15082 SQLITE_PRIVATE void sqlite3StatusDown(int op, int N){ in sqlite3StatusDown() argument
15085 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusDown()
15086 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusDown()
15088 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusDown()
15089 wsdStat.nowValue[op] -= N; in sqlite3StatusDown()
15096 SQLITE_PRIVATE void sqlite3StatusSet(int op, int X){ in sqlite3StatusSet() argument
15098 assert( op>=0 && op<ArraySize(wsdStat.nowValue) ); in sqlite3StatusSet()
15099 assert( op>=0 && op<ArraySize(statMutex) ); in sqlite3StatusSet()
15100 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex() in sqlite3StatusSet()
15102 wsdStat.nowValue[op] = X; in sqlite3StatusSet()
15103 if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){ in sqlite3StatusSet()
15104 wsdStat.mxValue[op] = wsdStat.nowValue[op]; in sqlite3StatusSet()
15112 int op, in sqlite3_status64() argument
15119 if( op<0 || op>=ArraySize(wsdStat.nowValue) ){ in sqlite3_status64()
15125 pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex(); in sqlite3_status64()
15127 *pCurrent = wsdStat.nowValue[op]; in sqlite3_status64()
15128 *pHighwater = wsdStat.mxValue[op]; in sqlite3_status64()
15130 wsdStat.mxValue[op] = wsdStat.nowValue[op]; in sqlite3_status64()
15136 SQLITE_API int SQLITE_STDCALL sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag){ in sqlite3_status() argument
15142 rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag); in sqlite3_status()
15155 int op, /* Status verb */ in sqlite3_db_status() argument
15167 switch( op ){ in sqlite3_db_status()
15180 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT ); in sqlite3_db_status()
15181 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE ); in sqlite3_db_status()
15182 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL ); in sqlite3_db_status()
15183 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 ); in sqlite3_db_status()
15184 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 ); in sqlite3_db_status()
15186 *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT]; in sqlite3_db_status()
15188 db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0; in sqlite3_db_status()
15296 sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet); in sqlite3_db_status()
16574 SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){ in sqlite3OsFileControl() argument
16576 if( op!=SQLITE_FCNTL_COMMIT_PHASETWO ){ in sqlite3OsFileControl()
16590 return id->pMethods->xFileControl(id, op, pArg); in sqlite3OsFileControl()
16592 SQLITE_PRIVATE void sqlite3OsFileControlHint(sqlite3_file *id, int op, void *pArg){ in sqlite3OsFileControlHint() argument
16593 (void)id->pMethods->xFileControl(id, op, pArg); in sqlite3OsFileControlHint()
26115 static int lockTrace(int fd, int op, struct flock *p){
26119 if( op==F_GETLK ){
26121 }else if( op==F_SETLK ){
26124 s = osFcntl(fd, op, p);
26125 sqlite3DebugPrintf("fcntl unknown %d %d %d\n", fd, op, s);
26138 s = osFcntl(fd, op, p);
26143 if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
27700 static int robust_flock(int fd, int op){
27702 do{ rc = flock(fd,op); }while( rc<0 && errno==EINTR );
29237 static int unixFileControl(sqlite3_file *id, int op, void *pArg){
29239 switch( op ){
29319 return proxyFileControl(id,op,pArg);
32689 static int proxyFileControl(sqlite3_file *id, int op, void *pArg){
32690 switch( op ){
36436 static int winFileControl(sqlite3_file *id, int op, void *pArg){
36438 OSTRACE(("FCNTL file=%p, op=%d, pArg=%p\n", pFile->h, op, pArg));
36439 switch( op ){
39181 int i, nx, pc, op;
39197 while( (op = aOp[pc])!=0 ){
39198 switch( op ){
39218 if( (op & 1)!=0 ){
39220 if( op!=5 ){
41634 SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op);
48196 SQLITE_PRIVATE int sqlite3PagerSavepoint(Pager *pPager, int op, int iSavepoint){
48199 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
48200 assert( iSavepoint>=0 || op==SAVEPOINT_ROLLBACK );
48210 nNew = iSavepoint + (( op==SAVEPOINT_RELEASE ) ? 0 : 1);
48218 if( op==SAVEPOINT_RELEASE ){
52002 SQLITE_PRIVATE int sqlite3WalExclusiveMode(Wal *pWal, int op){
52005 assert( pWal->exclusiveMode!=WAL_HEAPMEMORY_MODE || op==-1 );
52014 assert( pWal->readLock>=0 || (op<=0 && pWal->exclusiveMode==0) );
52016 if( op==0 ){
52027 }else if( op>0 ){
56822 SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
56826 assert( op==SAVEPOINT_RELEASE || op==SAVEPOINT_ROLLBACK );
56827 assert( iSavepoint>=0 || (iSavepoint==-1 && op==SAVEPOINT_ROLLBACK) );
56829 rc = sqlite3PagerSavepoint(pBt->pPager, op, iSavepoint);
64349 int op;
64360 while( (op = pExpr->op)==TK_UPLUS ) pExpr = pExpr->pLeft;
64361 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
64369 if( op==TK_CAST ){
64383 if( op==TK_UMINUS
64384 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
64386 op = pExpr->op;
64391 if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
64401 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
64410 }else if( op==TK_UMINUS ) {
64426 }else if( op==TK_NULL ){
64431 else if( op==TK_BLOB ){
64446 else if( op==TK_FUNCTION && pCtx!=0 ){
64579 }else if( pExpr->op==TK_VARIABLE
64580 || NEVER(pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
64931 SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
64937 assert( op>0 && op<0xff );
64945 pOp->opcode = (u8)op;
64979 SQLITE_PRIVATE int sqlite3VdbeAddOp0(Vdbe *p, int op){
64980 return sqlite3VdbeAddOp3(p, op, 0, 0, 0);
64982 SQLITE_PRIVATE int sqlite3VdbeAddOp1(Vdbe *p, int op, int p1){
64983 return sqlite3VdbeAddOp3(p, op, p1, 0, 0);
64985 SQLITE_PRIVATE int sqlite3VdbeAddOp2(Vdbe *p, int op, int p1, int p2){
64986 return sqlite3VdbeAddOp3(p, op, p1, p2, 0);
64995 int op, /* The new opcode */
65002 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
65027 int op, /* The new opcode */
65033 int addr = sqlite3VdbeAddOp3(p, op, p1, p2, p3);
65571 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
65572 if( (p->nOp-1)>(p->pParse->iFixedOp) && p->aOp[p->nOp-1].opcode==op ){
70472 SQLITE_API int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
70481 v = pVdbe->aCounter[op];
70482 if( resetFlag ) pVdbe->aCounter[op] = 0;
72494 u8 op;
72505 op = pOp->opcode;
72506 if( op==OP_BitAnd ){
72508 }else if( op==OP_BitOr ){
72511 assert( op==OP_ShiftRight || op==OP_ShiftLeft );
72516 op = 2*OP_ShiftLeft + 1 - op;
72521 iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
72524 if( op==OP_ShiftLeft ){
75009 int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
75057 op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
75059 db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey);
81327 if( pExpr->op==TK_AGG_FUNCTION ) pExpr->op2 += pWalker->u.n;
81401 if( pOrig->op!=TK_COLUMN && zType[0]!='G' ){
81411 if( pExpr->op==TK_COLLATE ){
81633 int op = pParse->eTriggerOp;
81634 assert( op==TK_DELETE || op==TK_UPDATE || op==TK_INSERT );
81635 if( op!=TK_DELETE && sqlite3StrICmp("new",zTab) == 0 ){
81638 }else if( op!=TK_INSERT && sqlite3StrICmp("old",zTab)==0 ){
81756 pExpr->op = TK_STRING;
81801 pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN);
81805 if( pExpr->op!=TK_AS ){
81884 if( p->op!=TK_FLOAT ) return -1;
81922 switch( pExpr->op ){
81934 pExpr->op = TK_COLUMN;
81961 if( pRight->op==TK_ID ){
81966 assert( pRight->op==TK_DOT );
82033 pExpr->op = TK_NULL;
82057 pExpr->op = TK_AGG_FUNCTION;
82079 case TK_EXISTS: testcase( pExpr->op==TK_EXISTS );
82082 testcase( pExpr->op==TK_IN );
82125 if( pE->op==TK_ID ){
82292 assert( pParent->op==TK_COLLATE );
82293 while( pParent->pLeft->op==TK_COLLATE ) pParent = pParent->pLeft;
82837 int op;
82840 op = pExpr->op;
82841 if( op==TK_SELECT ){
82846 if( op==TK_CAST ){
82851 if( (op==TK_AGG_COLUMN || op==TK_COLUMN || op==TK_REGISTER)
82905 assert( pExpr->op==TK_FUNCTION );
82908 assert( pExpr->op==TK_COLLATE || pExpr->op==TK_AS );
82929 int op = p->op;
82931 if( op==TK_CAST || op==TK_UPLUS ){
82935 if( op==TK_COLLATE || (op==TK_REGISTER && p->op2==TK_COLLATE) ){
82939 if( (op==TK_AGG_COLUMN || op==TK_COLUMN
82940 || op==TK_REGISTER || op==TK_TRIGGER)
83017 assert( pExpr->op==TK_EQ || pExpr->op==TK_IN || pExpr->op==TK_LT ||
83018 pExpr->op==TK_GT || pExpr->op==TK_GE || pExpr->op==TK_LE ||
83019 pExpr->op==TK_NE || pExpr->op==TK_IS || pExpr->op==TK_ISNOT );
83252 int op, /* Expression opcode */
83261 if( op!=TK_INTEGER || pToken->z==0
83269 pNew->op = (u8)op;
83301 int op, /* Expression opcode */
83307 return sqlite3ExprAlloc(db, op, &x, 0);
83348 int op, /* Expression opcode */
83354 if( op==TK_AND && pLeft && pRight && pParse->nErr==0 ){
83358 p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
83895 pNew->op = p->op;
84099 switch( pExpr->op ){
84114 testcase( pExpr->op==TK_ID );
84115 testcase( pExpr->op==TK_COLUMN );
84116 testcase( pExpr->op==TK_AGG_FUNCTION );
84117 testcase( pExpr->op==TK_AGG_COLUMN );
84129 pExpr->op = TK_NULL;
84138 testcase( pExpr->op==TK_SELECT ); /* selectNodeIsConstant will disallow */
84139 testcase( pExpr->op==TK_EXISTS ); /* selectNodeIsConstant will disallow */
84216 assert( p->op!=TK_INTEGER || (p->flags & EP_IntValue)!=0
84223 switch( p->op ){
84257 u8 op;
84258 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
84259 op = p->op;
84260 if( op==TK_REGISTER ) op = p->op2;
84261 switch( op ){
84287 u8 op;
84289 while( p->op==TK_UPLUS || p->op==TK_UMINUS ){ p = p->pLeft; }
84290 op = p->op;
84291 if( op==TK_REGISTER ) op = p->op2;
84292 switch( op ){
84364 if( pEList->a[0].pExpr->op!=TK_COLUMN ) return 0; /* Result is a column */
84490 assert( pX->op==TK_IN );
84665 pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
84671 switch( pExpr->op ){
84802 testcase( pExpr->op==TK_EXISTS );
84803 testcase( pExpr->op==TK_SELECT );
84804 assert( pExpr->op==TK_EXISTS || pExpr->op==TK_SELECT );
84809 if( pExpr->op==TK_SELECT ){
85250 int op = IsVirtual(pTab) ? OP_VColumn : OP_Column;
85255 sqlite3VdbeAddOp3(v, op, iTabCur, x, regOut);
85361 p->op2 = p->op;
85362 p->op = TK_REGISTER;
85380 int op; /* The opcode being coded */
85395 op = TK_NULL;
85397 op = pExpr->op;
85399 switch( op ){
85510 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
85512 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
85513 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
85514 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
85515 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
85516 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
85517 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
85524 testcase( op==TK_IS );
85525 testcase( op==TK_ISNOT );
85528 op = (op==TK_IS) ? TK_EQ : TK_NE;
85529 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
85531 VdbeCoverageIf(v, op==TK_EQ);
85532 VdbeCoverageIf(v, op==TK_NE);
85549 assert( TK_AND==OP_And ); testcase( op==TK_AND );
85550 assert( TK_OR==OP_Or ); testcase( op==TK_OR );
85551 assert( TK_PLUS==OP_Add ); testcase( op==TK_PLUS );
85552 assert( TK_MINUS==OP_Subtract ); testcase( op==TK_MINUS );
85553 assert( TK_REM==OP_Remainder ); testcase( op==TK_REM );
85554 assert( TK_BITAND==OP_BitAnd ); testcase( op==TK_BITAND );
85555 assert( TK_BITOR==OP_BitOr ); testcase( op==TK_BITOR );
85556 assert( TK_SLASH==OP_Divide ); testcase( op==TK_SLASH );
85557 assert( TK_LSHIFT==OP_ShiftLeft ); testcase( op==TK_LSHIFT );
85558 assert( TK_RSHIFT==OP_ShiftRight ); testcase( op==TK_RSHIFT );
85559 assert( TK_CONCAT==OP_Concat ); testcase( op==TK_CONCAT );
85562 sqlite3VdbeAddOp3(v, op, r2, r1, target);
85570 if( pLeft->op==TK_INTEGER ){
85573 }else if( pLeft->op==TK_FLOAT ){
85578 tempX.op = TK_INTEGER;
85591 assert( TK_BITNOT==OP_BitNot ); testcase( op==TK_BITNOT );
85592 assert( TK_NOT==OP_Not ); testcase( op==TK_NOT );
85596 sqlite3VdbeAddOp2(v, op, r1, inReg);
85602 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
85603 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
85607 addr = sqlite3VdbeAddOp1(v, op, r1);
85608 VdbeCoverageIf(v, op==TK_ISNULL);
85609 VdbeCoverageIf(v, op==TK_NOTNULL);
85706 exprOp = pFarg->a[0].pExpr->op;
85757 testcase( op==TK_EXISTS );
85758 testcase( op==TK_SELECT );
85896 default: assert( op==TK_CASE ); {
85916 testcase( pX->op==TK_COLUMN );
85919 opCompare.op = TK_EQ;
85937 testcase( pTest->op==TK_COLUMN );
85939 testcase( aListelem[i+1].pExpr->op==TK_COLUMN );
86030 && pExpr->op!=TK_REGISTER
86068 if( pExpr && pExpr->op==TK_REGISTER ){
86110 assert( pExpr->op!=TK_REGISTER );
86130 switch( pExpr->op ){
86243 if( pExpr->op==TK_AGG_FUNCTION ){
86330 sqlite3TreeViewLine(pView, "op=%d", pExpr->op);
86456 exprAnd.op = TK_AND;
86459 compLeft.op = TK_GE;
86462 compRight.op = TK_LE;
86500 int op = 0;
86508 op = pExpr->op;
86509 switch( op ){
86542 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
86544 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86545 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86546 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86547 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86548 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86549 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86556 testcase( op==TK_IS );
86557 testcase( op==TK_ISNOT );
86560 op = (op==TK_IS) ? TK_EQ : TK_NE;
86561 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
86563 VdbeCoverageIf(v, op==TK_EQ);
86564 VdbeCoverageIf(v, op==TK_NE);
86571 assert( TK_ISNULL==OP_IsNull ); testcase( op==TK_ISNULL );
86572 assert( TK_NOTNULL==OP_NotNull ); testcase( op==TK_NOTNULL );
86574 sqlite3VdbeAddOp2(v, op, r1, dest);
86575 VdbeCoverageIf(v, op==TK_ISNULL);
86576 VdbeCoverageIf(v, op==TK_NOTNULL);
86625 int op = 0;
86652 op = ((pExpr->op+(TK_ISNULL&1))^1)-(TK_ISNULL&1);
86656 assert( pExpr->op!=TK_ISNULL || op==OP_NotNull );
86657 assert( pExpr->op!=TK_NOTNULL || op==OP_IsNull );
86658 assert( pExpr->op!=TK_NE || op==OP_Eq );
86659 assert( pExpr->op!=TK_EQ || op==OP_Ne );
86660 assert( pExpr->op!=TK_LT || op==OP_Ge );
86661 assert( pExpr->op!=TK_LE || op==OP_Gt );
86662 assert( pExpr->op!=TK_GT || op==OP_Le );
86663 assert( pExpr->op!=TK_GE || op==OP_Lt );
86665 switch( pExpr->op ){
86698 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
86700 assert(TK_LT==OP_Lt); testcase(op==OP_Lt); VdbeCoverageIf(v,op==OP_Lt);
86701 assert(TK_LE==OP_Le); testcase(op==OP_Le); VdbeCoverageIf(v,op==OP_Le);
86702 assert(TK_GT==OP_Gt); testcase(op==OP_Gt); VdbeCoverageIf(v,op==OP_Gt);
86703 assert(TK_GE==OP_Ge); testcase(op==OP_Ge); VdbeCoverageIf(v,op==OP_Ge);
86704 assert(TK_EQ==OP_Eq); testcase(op==OP_Eq); VdbeCoverageIf(v,op==OP_Eq);
86705 assert(TK_NE==OP_Ne); testcase(op==OP_Ne); VdbeCoverageIf(v,op==OP_Ne);
86712 testcase( pExpr->op==TK_IS );
86713 testcase( pExpr->op==TK_ISNOT );
86716 op = (pExpr->op==TK_IS) ? TK_NE : TK_EQ;
86717 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
86719 VdbeCoverageIf(v, op==TK_EQ);
86720 VdbeCoverageIf(v, op==TK_NE);
86728 sqlite3VdbeAddOp2(v, op, r1, dest);
86729 testcase( op==TK_ISNULL ); VdbeCoverageIf(v, op==TK_ISNULL);
86730 testcase( op==TK_NOTNULL ); VdbeCoverageIf(v, op==TK_NOTNULL);
86804 if( pA->op!=pB->op ){
86805 if( pA->op==TK_COLLATE && sqlite3ExprCompare(pA->pLeft, pB, iTab)<2 ){
86808 if( pB->op==TK_COLLATE && sqlite3ExprCompare(pA, pB->pLeft, iTab)<2 ){
86813 if( pA->op!=TK_COLUMN && ALWAYS(pA->op!=TK_AGG_COLUMN) && pA->u.zToken ){
86815 return pA->op==TK_COLLATE ? 1 : 2;
86824 if( ALWAYS((combinedFlags & EP_Reduced)==0) && pA->op!=TK_STRING ){
86886 if( pE2->op==TK_OR
86892 if( pE2->op==TK_NOTNULL
86894 && (pE1->op!=TK_ISNULL && pE1->op!=TK_IS)
86922 if( pExpr->op==TK_COLUMN || NEVER(pExpr->op==TK_AGG_COLUMN) ){
86948 assert( pExpr->op==TK_AGG_FUNCTION );
87003 switch( pExpr->op ){
87006 testcase( pExpr->op==TK_AGG_COLUMN );
87007 testcase( pExpr->op==TK_COLUMN );
87047 if( pE->op==TK_COLUMN && pE->iTable==pExpr->iTable &&
87065 pExpr->op = TK_AGG_COLUMN;
87889 if( pDflt && pDflt->op==TK_NULL ){
89994 if( pExpr->op!=TK_ID ){
89997 pExpr->op = TK_STRING;
90296 if( pAuthArg->op==TK_STRING ){
90483 if( pExpr->op==TK_VARIABLE ){
90485 pExpr->op = TK_NULL;
90703 assert( pExpr->op==TK_COLUMN || pExpr->op==TK_TRIGGER );
90704 if( pExpr->op==TK_TRIGGER ){
90729 pExpr->op = TK_NULL;
93827 assert( pExpr->op==TK_COLLATE );
93896 assert( pListItem->pExpr->op==TK_COLLATE );
94655 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
94663 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
94667 sqlite3VdbeAddOp4(v, OP_Savepoint, op, 0, 0, zName, P4_DYNAMIC);
98086 if( pExpr->op!=TK_FUNCTION
99536 pStep->op = TK_SELECT;
99540 pStep->op = TK_DELETE;
99544 pStep->op = TK_UPDATE;
99550 pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
101099 int op = OP_Ne;
101107 op = OP_Eq;
101109 sqlite3VdbeAddOp4(v, op,
101113 VdbeCoverageIf(v, op==OP_Eq);
101114 VdbeCoverageIf(v, op==OP_Ne);
101256 int op, /* OP_OpenRead or OP_OpenWrite */
101268 assert( op==OP_OpenRead || op==OP_OpenWrite );
101282 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
101284 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
101294 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
101473 if( pEList->a[0].pExpr->op!=TK_ALL ){
102092 int (*vtab_config)(sqlite3*,int op,...);
106597 pNew->op = TK_SELECT;
106969 int op; /* Opcode to add sorter record to sorter */
107026 op = OP_SorterInsert;
107028 op = OP_IdxInsert;
107030 sqlite3VdbeAddOp2(v, op, pSort->iECursor, regRecord);
107603 int op, /* One of TK_UNION, TK_EXCEPT etc. */
107608 assert( op==TK_UNION || op==TK_EXCEPT || op==TK_INTERSECT || op==TK_ALL );
107613 bUseTmp?"USING TEMP B-TREE ":"", selectOpName(op)
107800 switch( pExpr->op ){
107810 testcase( pExpr->op==TK_AGG_COLUMN );
107811 testcase( pExpr->op==TK_COLUMN );
107996 }else if( (p->op==TK_COLUMN || p->op==TK_AGG_COLUMN) && pTabList ){
108080 while( pColExpr->op==TK_DOT ){
108084 if( pColExpr->op==TK_COLUMN && ALWAYS(pColExpr->pTab!=0) ){
108091 }else if( pColExpr->op==TK_ID ){
108461 if( p->op==TK_UNION ){
108555 " do not have the same number of result columns", selectOpName(p->op));
108582 assert( p->op==TK_ALL || (p->op==TK_SELECT && p->pPrior==0) );
108657 assert( (p->selFlags & SF_Recursive)==0 || p->op==TK_ALL || p->op==TK_UNION );
108663 selectOpName(p->op));
108669 selectOpName(p->op));
108717 switch( p->op ){
108760 u8 op = 0; /* One of the SRT_ operations to apply to self */
108766 testcase( p->op==TK_EXCEPT );
108767 testcase( p->op==TK_UNION );
108801 if( p->op==TK_EXCEPT ){
108802 op = SRT_Except;
108804 assert( p->op==TK_UNION );
108805 op = SRT_Union;
108812 uniondest.eDest = op;
108822 if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
108855 default: assert( p->op==TK_INTERSECT ); {
108935 explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
109267 int op; /* One of TK_ALL, TK_UNION, TK_EXCEPT, TK_INTERSECT */
109290 op = p->op;
109301 if( op!=TK_ALL ){
109350 if( op==TK_ALL ){
109379 if( p->iLimit && op==TK_ALL ){
109439 if( op==TK_ALL || op==TK_UNION ){
109450 if( op==TK_EXCEPT || op==TK_INTERSECT ){
109464 if( op==TK_INTERSECT ){
109483 if( op==TK_ALL ){
109485 }else if( op==TK_INTERSECT ){
109499 if( op==TK_ALL || op==TK_UNION ){
109542 explainComposite(pParse, p->op, iSub1, iSub2, 0);
109572 if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){
109574 pExpr->op = TK_NULL;
109904 || (pSub1->pPrior && pSub1->op!=TK_ALL)
109982 p->op = TK_ALL;
110218 assert( pExpr->op==TK_AGG_FUNCTION );
110219 if( pEList && pEList->nExpr==1 && pEList->a[0].pExpr->op==TK_AGG_COLUMN ){
110262 if( pExpr->op!=TK_AGG_FUNCTION ) return 0;
110328 for(pX=p; pX && (pX->op==TK_ALL || pX->op==TK_SELECT); pX=pX->pPrior){}
110348 p->op = TK_SELECT;
110475 bMayRecursive = ( pSel->op==TK_ALL || pSel->op==TK_UNION );
110696 if( pE->op==TK_ALL ) break;
110697 assert( pE->op!=TK_DOT || pE->pRight!=0 );
110698 assert( pE->op!=TK_DOT || (pE->pLeft!=0 && pE->pLeft->op==TK_ID) );
110699 if( pE->op==TK_DOT && pE->pRight->op==TK_ALL ) break;
110723 assert( pE->op!=TK_DOT || pRight!=0 );
110724 if( pE->op!=TK_ALL && (pE->op!=TK_DOT || pRight->op!=TK_ALL) ){
110740 if( pE->op==TK_DOT ){
111905 pMinMax->a[0].pExpr->op = TK_COLUMN;
112062 switch( p->op ){
112362 int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
112380 assert( op==TK_INSERT || op==TK_UPDATE || op==TK_DELETE );
112381 assert( op>0 && op<0xff );
112523 pTrigger->op = (u8)op;
112633 pTriggerStep->op = TK_SELECT;
112647 u8 op, /* Trigger opcode */
112658 pTriggerStep->op = op;
112916 int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
112929 if( p->op==op && checkColumnOverlap(p->pColumns, pChanges) ){
113003 switch( pStep->op ){
113029 default: assert( pStep->op==TK_SELECT ); {
113038 if( pStep->op!=TK_SELECT ){
113129 pSubParse->eTriggerOp = pTrigger->op;
113137 (pTrigger->op==TK_UPDATE ? "UPDATE" : ""),
113138 (pTrigger->op==TK_INSERT ? "INSERT" : ""),
113139 (pTrigger->op==TK_DELETE ? "DELETE" : ""),
113308 int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
113318 assert( op==TK_UPDATE || op==TK_INSERT || op==TK_DELETE );
113320 assert( (op==TK_UPDATE)==(pChanges!=0) );
113333 if( p->op==op
113376 const int op = pChanges ? TK_UPDATE : TK_DELETE;
113382 if( p->op==op && (tr_tm&p->tr_tm)
115511 SQLITE_PRIVATE int sqlite3VtabSavepoint(sqlite3 *db, int op, int iSavepoint){
115514 assert( op==SAVEPOINT_RELEASE||op==SAVEPOINT_ROLLBACK||op==SAVEPOINT_BEGIN );
115523 switch( op ){
115576 if( pExpr->op!=TK_COLUMN ) return pDef;
115667 SQLITE_API int SQLITE_CDECL sqlite3_vtab_config(sqlite3 *db, int op, ...){
115675 va_start(ap, op);
115676 switch( op ){
115796 u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */
116036 u8 op; /* Split operator. TK_AND or TK_OR */
116431 static void whereSplit(WhereClause *pWC, Expr *pExpr, u8 op){
116433 pWC->op = op;
116435 if( pE2->op!=op ){
116438 whereSplit(pWC, pE2->pLeft, op);
116439 whereSplit(pWC, pE2->pRight, op);
116486 if( p->op==TK_COLUMN ){
116535 static int allowedOp(int op){
116540 return op==TK_IN || (op>=TK_EQ && op<=TK_GE) || op==TK_ISNULL;
116558 assert( allowedOp(pExpr->op) && pExpr->op!=TK_IN );
116573 if( pExpr->op>=TK_GT ){
116578 assert( pExpr->op>=TK_GT && pExpr->op<=TK_GE );
116579 pExpr->op = ((pExpr->op-TK_GT)^2)+TK_GT;
116586 static u16 operatorMask(int op){
116588 assert( allowedOp(op) );
116589 if( op==TK_IN ){
116591 }else if( op==TK_ISNULL ){
116594 assert( (WO_EQ<<(op-TK_EQ)) < 0x7fff );
116595 c = (u16)(WO_EQ<<(op-TK_EQ));
116597 assert( op!=TK_ISNULL || c==WO_ISNULL );
116598 assert( op!=TK_IN || c==WO_IN );
116599 assert( op!=TK_EQ || c==WO_EQ );
116600 assert( op!=TK_LT || c==WO_LT );
116601 assert( op!=TK_LE || c==WO_LE );
116602 assert( op!=TK_GT || c==WO_GT );
116603 assert( op!=TK_GE || c==WO_GE );
116634 assert( pX->op==TK_COLUMN );
116665 && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN
116762 u32 op, /* Mask of WO_xx values describing operator */
116769 p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
116826 int op; /* Opcode of pRight */
116836 if( pLeft->op!=TK_COLUMN
116847 op = pRight->op;
116848 if( op==TK_VARIABLE ){
116856 assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
116857 }else if( op==TK_STRING ){
116871 if( op==TK_VARIABLE ){
116911 if( pExpr->op!=TK_FUNCTION ){
116921 if( pList->a[1].pExpr->op != TK_COLUMN ){
116992 int op; /* Operator for the combined expression */
117015 for(op=TK_EQ; eOp!=(WO_EQ<<(op-TK_EQ)); op++){ assert( op<TK_GE ); }
117016 pNew->op = op;
117132 assert( pExpr->op==TK_OR );
117171 if( allowedOp(pAndTerm->pExpr->op) ){
117386 int op; /* Top-level operator. pExpr->op */
117396 assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE );
117398 op = pExpr->op;
117399 if( op==TK_IN ){
117406 }else if( op==TK_ISNULL ){
117422 if( allowedOp(op) ){
117426 if( pLeft->op==TK_COLUMN ){
117429 pTerm->eOperator = operatorMask(op) & opMask;
117431 if( pRight && pRight->op==TK_COLUMN ){
117448 if( pExpr->op==TK_EQ
117466 pNew->eOperator = (operatorMask(pDup->op) + eExtraOp) & opMask;
117486 else if( pExpr->op==TK_BETWEEN && pWC->op==TK_AND ){
117512 else if( pExpr->op==TK_OR ){
117513 assert( pWC->op==TK_AND );
117533 if( pWC->op==TK_AND
117650 if( pExpr->op==TK_NOTNULL
117651 && pExpr->pLeft->op==TK_COLUMN
117705 if( p->op==TK_COLUMN
117750 if( p->op==TK_COLUMN && p->iTable==iBase && p->iColumn<0 ) return 1;
117809 p->aConstraint[i].op,
118088 if( pExpr->op!=TK_COLUMN || pExpr->iTable!=pSrc->iCursor ) break;
118121 u8 op;
118131 op = (u8)pTerm->eOperator & WO_ALL;
118132 if( op==WO_IN ) op = WO_EQ;
118133 pIdxCons[j].op = op;
118969 if( pX->op==TK_EQ ){
118971 }else if( pX->op==TK_ISNULL ){
118989 assert( pX->op==TK_IN );
119484 pLevel->op = OP_Goto;
119522 pLevel->op = OP_VNext;
119554 pLevel->op = OP_Noop;
119599 sqlite3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1);
119601 VdbeCoverageIf(v, pX->op==TK_GT);
119602 VdbeCoverageIf(v, pX->op==TK_LE);
119603 VdbeCoverageIf(v, pX->op==TK_LT);
119604 VdbeCoverageIf(v, pX->op==TK_GE);
119622 if( pX->op==TK_LT || pX->op==TK_GT ){
119630 pLevel->op = bRev ? OP_Prev : OP_Next;
119704 int op; /* Instruction opcode */
119829 op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev];
119830 assert( op!=0 );
119831 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
119833 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind );
119834 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last );
119835 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT );
119836 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE );
119837 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE );
119838 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT );
119874 op = aEndOp[bRev*2 + endEq];
119875 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint);
119876 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT );
119877 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE );
119878 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT );
119879 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE );
119907 pLevel->op = OP_Noop;
119909 pLevel->op = OP_Prev;
119911 pLevel->op = OP_Next;
119988 pLevel->op = OP_Return;
120219 pLevel->op = OP_Noop;
120221 pLevel->op = aStep[bRev];
121155 if( pExpr->op!=TK_COLUMN ) return 0;
121646 tempWC.op = TK_AND;
121864 if( pOBExpr->op!=TK_COLUMN ) continue;
121951 if( pOBExpr->op!=TK_COLUMN ) continue;
122929 int op = OP_OpenRead;
122931 op = OP_OpenWrite;
122934 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
122952 int op = OP_OpenRead;
122961 op = 0;
122970 op = OP_OpenWrite;
122974 if( wctrlFlags & WHERE_REOPEN_IDX ) op = OP_ReopenIdx;
122981 if( op ){
122982 sqlite3VdbeAddOp3(v, op, iIndexCur, pIx->tnum, iDb);
123062 if( pLevel->op!=OP_Noop ){
123063 sqlite3VdbeAddOp3(v, pLevel->op, pLevel->p1, pLevel->p2, pLevel->p3);
123066 VdbeCoverageIf(v, pLevel->op==OP_Next);
123067 VdbeCoverageIf(v, pLevel->op==OP_Prev);
123068 VdbeCoverageIf(v, pLevel->op==OP_VNext);
123091 int op;
123093 op = OP_DecrJumpZero;
123095 op = OP_JumpZeroIncr;
123097 sqlite3VdbeAddOp2(v, op, pLevel->iLikeRepCntr, pLevel->addrLikeRep);
123110 if( pLevel->op==OP_Return ){
123328 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
123329 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
123340 int op, /* The binary operation */
123344 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
123354 int op, /* The operator */
123358 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
123365 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
123367 if( pY && pA && pY->op==TK_NULL ){
123368 pA->op = (u8)op;
123379 int op, /* The operator */
123383 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
125657 pRhs->op = (u8)yymsp[-1].minor.yy328;
125710 pRight->op = TK_ALL;
128335 SQLITE_API int SQLITE_CDECL sqlite3_config(int op, ...){
128343 va_start(ap, op);
128344 switch( op ){
128729 SQLITE_API int SQLITE_CDECL sqlite3_db_config(sqlite3 *db, int op, ...){
128732 va_start(ap, op);
128733 switch( op ){
128743 int op; /* The opcode */
128752 if( aFlagOp[i].op==op ){
131312 SQLITE_API int SQLITE_STDCALL sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *…
131329 if( op==SQLITE_FCNTL_FILE_POINTER ){
131333 rc = sqlite3OsFileControl(fd, op, pArg);
131346 SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...){
131350 va_start(ap, op);
131351 switch( op ){
134541 if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){
134558 if( iCons<0 && pCons->op==SQLITE_INDEX_CONSTRAINT_EQ && bDocid ){
134573 if( pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH
134582 if( pCons->op==SQLITE_INDEX_CONSTRAINT_EQ
134589 switch( pCons->op ){
139062 int op = pInfo->aConstraint[i].op;
139066 if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iEq = i;
139067 if( op==SQLITE_INDEX_CONSTRAINT_LT ) iLe = i;
139068 if( op==SQLITE_INDEX_CONSTRAINT_LE ) iLe = i;
139069 if( op==SQLITE_INDEX_CONSTRAINT_GT ) iGe = i;
139070 if( op==SQLITE_INDEX_CONSTRAINT_GE ) iGe = i;
139073 if( op==SQLITE_INDEX_CONSTRAINT_EQ ) iLangid = i;
142746 && pInfo->aConstraint[i].op==SQLITE_INDEX_CONSTRAINT_EQ
151242 int op; /* Constraining operation */
151932 assert( pConstraint->op==RTREE_MATCH || pConstraint->op==RTREE_QUERY );
151935 if( pConstraint->op==RTREE_QUERY && pSearch->iLevel==1 ){
151942 if( pConstraint->op==RTREE_MATCH ){
151979 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
151980 || p->op==RTREE_GT || p->op==RTREE_EQ );
151981 switch( p->op ){
151988 if( p->op!=RTREE_EQ ) break; /* RTREE_LE and RTREE_LT end here */
152018 assert(p->op==RTREE_LE || p->op==RTREE_LT || p->op==RTREE_GE
152019 || p->op==RTREE_GT || p->op==RTREE_EQ );
152022 switch( p->op ){
152309 if( pConstraint->op>=RTREE_MATCH ){
152480 pCons->op = RTREE_QUERY;
152547 p->op = idxStr[ii*2];
152549 if( p->op>=RTREE_MATCH ){
152652 if( p->usable && p->iColumn==0 && p->op==SQLITE_INDEX_CONSTRAINT_EQ ){
152674 if( p->usable && (p->iColumn>0 || p->op==SQLITE_INDEX_CONSTRAINT_MATCH) ){
152675 u8 op;
152676 switch( p->op ){
152677 case SQLITE_INDEX_CONSTRAINT_EQ: op = RTREE_EQ; break;
152678 case SQLITE_INDEX_CONSTRAINT_GT: op = RTREE_GT; break;
152679 case SQLITE_INDEX_CONSTRAINT_LE: op = RTREE_LE; break;
152680 case SQLITE_INDEX_CONSTRAINT_LT: op = RTREE_LT; break;
152681 case SQLITE_INDEX_CONSTRAINT_GE: op = RTREE_GE; break;
152683 assert( p->op==SQLITE_INDEX_CONSTRAINT_MATCH );
152684 op = RTREE_MATCH;
152687 zIdxStr[iIdx++] = op;
