Lines Matching defs:mask
3636 ** function X against [database connection] D, using property mask M
3638 ** NULL or if the M mask is zero, then tracing is disabled. The
3646 ** mask M occur. ^The integer return value from the callback is currently
7467 ** the corresponding bit is set within the colUsed mask if the column may be
7506 ** mask of SQLITE_INDEX_SCAN_* flags. Currently there is only one such flag -
15254 ** Flags that make up the mask passed to sqlite3PagerGet().
15765 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor*, unsigned int mask);
16194 #define OP_ReleaseReg 183 /* synopsis: release r[P1@P2] mask P3 */
16315 SQLITE_PRIVATE void sqlite3VdbeReleaseRegisters(Parse*,int addr, int n, u32 mask, int);
17277 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0)
17278 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0)
18264 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
18320 /* If the EP_TokenOnly flag is set in the Expr.flags mask, then no
18332 /* If the EP_Reduced flag is set in the Expr.flags mask, then no
18406 /* The EP_Propagate mask is a set of properties that automatically propagate
19025 ** The TriggerPrg.aColmask[0] variable is set to a mask of old.* columns
19028 ** a mask of new.* columns used by the program.
25087 /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
26150 ** Return TRUE if the mask of type in eType matches the type of the
26172 ** Return TRUE if the mask of type in eType matches no bits of the type of the
34591 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
34593 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
35785 /* 183 */ "ReleaseReg" OpHelp("release r[P1@P2] mask P3"),
39828 long lk, mask;
39833 mask = (sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff;
39837 pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
40813 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
40815 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
40817 static void unixModeBit(unixFile *pFile, unsigned char mask, int *pArg){
40819 *pArg = (pFile->ctrlFlags & mask)!=0;
40821 pFile->ctrlFlags &= ~mask;
40823 pFile->ctrlFlags |= mask;
41254 ** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
41297 { u16 mask;
41299 mask = ofst>31 ? 0xffff : (1<<(ofst+n)) - (1<<ofst);
41303 pShmNode->exclMask &= ~mask;
41304 pShmNode->sharedMask &= ~mask;
41307 pShmNode->exclMask &= ~mask;
41308 pShmNode->sharedMask |= mask;
41312 pShmNode->exclMask |= mask;
41313 pShmNode->sharedMask &= ~mask;
41806 u16 mask; /* Mask of locks to take or release */
41859 mask = (1<<(ofst+n)) - (1<<ofst);
41860 assert( n>1 || mask==(1<<ofst) );
41864 if( (p->exclMask|p->sharedMask) & mask ){
41886 p->exclMask &= ~mask;
41887 p->sharedMask &= ~mask;
41893 if( (p->sharedMask & mask)==0 ){
41902 p->sharedMask |= mask;
41911 assert( (p->sharedMask & mask)==0 );
41923 assert( (p->sharedMask & mask)==0 );
41924 p->exclMask |= mask;
48568 ** 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
48570 ** If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
48572 static void winModeBit(winFile *pFile, unsigned char mask, int *pArg){
48574 *pArg = (pFile->ctrlFlags & mask)!=0;
48576 pFile->ctrlFlags &= ~mask;
48578 pFile->ctrlFlags |= mask;
49155 u16 mask; /* Mask of locks to take or release */
49169 mask = (u16)((1U<<(ofst+n)) - (1U<<ofst));
49170 assert( n>1 || mask==(1<<ofst) );
49183 if( (mask & allMask)==0 ){
49191 p->exclMask &= ~mask;
49192 p->sharedMask &= ~mask;
49202 if( (pX->exclMask & mask)!=0 ){
49211 if( (allShared & mask)==0 ){
49220 p->sharedMask |= mask;
49227 if( (pX->exclMask & mask)!=0 || (pX->sharedMask & mask)!=0 ){
49239 assert( (p->sharedMask & mask)==0 );
49240 p->exclMask |= mask;
79699 SQLITE_PRIVATE int sqlite3BtreeCursorHasHint(BtCursor *pCsr, unsigned int mask){
79700 return (pCsr->hints & mask)!=0;
82897 int p1, /* Constant argument mask */
83876 ** registers, except any identified by mask, are no longer in use.
83882 u32 mask, /* Mask of registers to NOT release */
83889 if( N<=31 && mask!=0 ){
83890 while( N>0 && (mask&1)!=0 ){
83891 mask >>= 1;
83895 while( N>0 && N<=32 && (mask & MASKBIT32(N-1))!=0 ){
83896 mask &= ~MASKBIT32(N-1);
83901 sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask);
84400 ** attached databases that will be use. A mask of these databases
86067 ** * the corresponding bit in argument mask is clear (where the first
86070 SQLITE_PRIVATE void sqlite3VdbeDeleteAuxData(sqlite3 *db, AuxData **pp, int iOp, int mask){
86076 && (pAux->iAuxArg>31 || !(mask & MASKBIT32(pAux->iAuxArg))))
94682 ** The P5 parameter can be a mask of the BTREE_* flags defined
99060 ** Synopsis: release r[P1@P2] mask P3
99067 ** In other words, P3 is a mask of registers to preserve.
103833 ** return the appropriate colUsed mask.
104396 ** The colUsed mask is an optimization used to help determine if an
104398 ** if the mask contains extra set bits. However, it is important to
107199 ** mask containing EXPRDUP_XXX flags.
108707 i64 mask = (1<<nExpr)-1;
108709 iTab, 0, 0, (u8*)&mask, P4_INT64);
117660 /* The cookie mask contains one bit for each database file open.
119765 ** The colNotIdxed mask is AND-ed with the SrcList.a[].colUsed mask
124467 u32 mask; /* Mask of OLD.* columns in use */
124473 mask = sqlite3TriggerColmask(
124476 mask |= sqlite3FkOldmask(pParse, pTab);
124484 testcase( mask!=0xffffffff && iCol==31 );
124485 testcase( mask!=0xffffffff && iCol==32 );
124486 if( mask==0xffffffff || (iCol<=31 && (mask & MASKBIT32(iCol))!=0) ){
124771 int mask; /* 0 for min() or 0xffffffff for max() */
124776 mask = sqlite3_user_data(context)==0 ? 0 : -1;
124779 assert( mask==-1 || mask==0 );
124784 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
124785 testcase( mask==0 );
125248 ** in a way that is testable, mask the sign bit off of negative
128218 u32 mask = 0;
128223 for(i=0; i<p->nCol; i++) mask |= COLUMN_MASK(p->aCol[i].iFrom);
128231 mask |= COLUMN_MASK(pIdx->aiColumn[i]);
128236 return mask;
134548 u32 mask =
134555 if( showInternFuncs ) mask = 0xffffffff;
134582 (p->funcFlags & mask) ^ SQLITE_INNOCUOUS
135366 u64 mask = pPragma->iArg; /* Mask of bits to set or clear. */
135370 mask &= ~(SQLITE_ForeignKeys);
135375 mask &= ~(SQLITE_WriteSchema);
135380 db->flags |= mask;
135382 db->flags &= ~mask;
135383 if( mask==SQLITE_DeferFKs ) db->nDeferredImmCons = 0;
135384 if( (mask & SQLITE_WriteSchema)!=0
137353 int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed);
137383 db->mDbFlags &= mask;
138474 u8 code; /* Join type mask */
142168 ** pSrcItem->colUsed mask.
147131 int mask = 0;
147156 mask |= p->tr_tm;
147172 mask |= p->tr_tm;
147176 mask |= p->tr_tm;
147183 *pMask = mask;
147185 return (mask ? pList : 0);
147785 ** Bit 0 of the returned mask is set if the left-most column of the
147794 ** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
147797 ** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
147799 ** included in the returned mask if the TRIGGER_BEFORE bit is set in the
147801 ** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
147807 int isNew, /* 1 for new.* ref mask, 0 for old.* ref mask */
147813 u32 mask = 0;
147823 mask = 0xffffffff;
147828 mask |= pPrg->aColmask[isNew];
147834 return mask;
148399 ** So reset the colUsed mask. Unless this is a virtual table. In that
148400 ** case, set all bits of the colUsed mask (to ensure that the virtual
151817 Bitmask notReady, /* RHS must not overlap with this mask */
155634 Bitmask mask = 0;
155637 mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pEList);
155638 mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pGroupBy);
155639 mask |= sqlite3WhereExprListUsage(pMaskSet, pS->pOrderBy);
155640 mask |= sqlite3WhereExprUsage(pMaskSet, pS->pWhere);
155641 mask |= sqlite3WhereExprUsage(pMaskSet, pS->pHaving);
155645 mask |= exprSelectUsage(pMaskSet, pSrc->a[i].pSelect);
155647 mask |= sqlite3WhereExprUsage(pMaskSet, pSrc->a[i].u3.pOn);
155650 mask |= sqlite3WhereExprListUsage(pMaskSet, pSrc->a[i].u1.pFuncArg);
155656 return mask;
156434 Bitmask mask;
156435 mask = (p->op==TK_IF_NULL_ROW) ? sqlite3WhereGetMask(pMaskSet, p->iTable) : 0;
156436 if( p->pLeft ) mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pLeft);
156438 mask |= sqlite3WhereExprUsageNN(pMaskSet, p->pRight);
156442 mask |= exprSelectUsage(pMaskSet, p->x.pSelect);
156444 mask |= sqlite3WhereExprListUsage(pMaskSet, p->x.pList);
156449 mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pPartition);
156450 mask |= sqlite3WhereExprListUsage(pMaskSet, p->y.pWin->pOrderBy);
156451 mask |= sqlite3WhereExprUsage(pMaskSet, p->y.pWin->pFilter);
156454 return mask;
156470 Bitmask mask = 0;
156473 mask |= sqlite3WhereExprUsage(pMaskSet, pList->a[i].pExpr);
156476 return mask;
156831 ** Create a new mask for cursor iCursor.
157054 Bitmask notReady, /* RHS must not overlap with this mask */
158431 u16 mask = WO_GT|WO_LE;
158432 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
158434 iNew = a[0] + ((pLower->eOperator & mask) ? a[1] : 0);
158448 u16 mask = WO_GT|WO_LE;
158449 if( sqlite3ExprVectorSize(pExpr)>n ) mask = (WO_LE|WO_LT);
158451 iNew = a[0] + ((pUpper->eOperator & mask) ? a[1] : 0);
160211 ** * It is not one of the operators specified in the mExclude mask passed
160214 ** Argument mPrereq is a mask of tables that must be scanned before the
160525 ** mUnusable are set to 0. Otherwise, mPrereq is a mask of all FROM clause
160528 ** mUnusable mask contains all FROM clause entries that occur after the
161231 ** If the WHERE_GROUPBY flag is set in the mask passed to sqlite3WhereBegin(),
162188 WhereMaskSet *pMaskSet; /* The expression mask set */
166717 struct {int value; int mask;} yy231;
170020 { yymsp[-1].minor.yy394 = (yymsp[-1].minor.yy394 & ~yymsp[0].minor.yy231.mask) | yymsp[0].minor.yy231.value; }
170023 { yymsp[-1].minor.yy231.value = 0; yymsp[-1].minor.yy231.mask = 0x000000; }
170026 { yymsp[-2].minor.yy231.value = 0; yymsp[-2].minor.yy231.mask = 0x000000; }
170029 { yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394; yymsp[-2].minor.yy231.mask = 0x0000ff; }
170032 { yymsp[-2].minor.yy231.value = yymsp[0].minor.yy394<<8; yymsp[-2].minor.yy231.mask = 0x00ff00; }
174368 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
174396 db->flags |= aFlagOp[i].mask;
174398 db->flags &= ~(u64)aFlagOp[i].mask;
174404 *pRes = (db->flags & aFlagOp[i].mask)!=0;
176484 int mask = 0;
176494 mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
176496 limit = mask;
176508 mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE
176511 limit = mask & flags;
176536 flags = (flags & ~mask) | mode;
176672 ** bits. Silently mask off all other flags.
196366 u64 hlmask = *pHlmask; /* Local copy of initial highlight-mask */
196441 u64 hlmask = pFragment->hlmask; /* Highlight-mask for snippet */
209041 char *zMask; /* Copy of update mask used with pUpdate */
233664 u32 mask;
233676 mask = aUsed[i];
233677 for(iSegid=0; mask & ((u32)1 << iSegid); iSegid++);
241628 int mask = 0;
241633 mask = (mask << 1) + bCons;
241635 return ((mask & 0x0007)==0x0005);
243210 ** SLOT_2_0 A mask for (0x7f<<14) | 0x7f
243212 ** SLOT_4_2_0 A mask for (0x7f<<28) | SLOT_2_0
243555 ** Bits for the mask used as the idxNum value by xBestIndex/xFilter.