contrib/sqlite3/sqlite3.c

9555 ** to the value of the iLimit parameter passed to xTruncate(). If any
9585   void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
9606   void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
18620 ** detailed description of the meaning of the iLimit and iOffset fields.
18636   int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
39656   int iLimit = 0;
39674     if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ) return SQLITE_ERROR;
48534     sqlite3_int64 iLimit = *(sqlite3_int64*)pArg;
48535     if( iLimit<p->sz ){
48536       if( iLimit<0 ){
48537         iLimit = p->szMax;
48539         iLimit = p->sz;
48542     p->szMax = iLimit;
48543     *(sqlite3_int64*)pArg = iLimit;
50847 ** greater than or equal to iLimit. Any pinned pages that meet this
50854   unsigned int iLimit          /* Drop pages with this pgno or larger */
50859   assert( pCache->iMaxKey >= iLimit );
50861   if( pCache->iMaxKey - iLimit < pCache->nHash ){
50866     h = iLimit % pCache->nHash;
50881       if( pPage->iKey>=iLimit ){
51350 ** or greater than parameter iLimit. Any pinned pages with a page number
51351 ** equal to or greater than iLimit are implicitly unpinned.
51353 static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
51356   if( iLimit<=pCache->iMaxKey ){
51357     pcache1TruncateUnsafe(pCache, iLimit);
51358     pCache->iMaxKey = iLimit-1;
53540     const i64 iLimit = pPager->journalSizeLimit;    /* Local cache of jsl */
53543     if( doTruncate || iLimit==0 ){
53559     if( rc==SQLITE_OK && iLimit>0 ){
53562       if( rc==SQLITE_OK && sz>iLimit ){
53563         rc = sqlite3OsTruncate(pPager->jfd, iLimit);
59520 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
59521   if( iLimit>=-1 ){
59522     pPager->journalSizeLimit = iLimit;
59523     sqlite3WalLimit(pPager->pWal, iLimit);
60857   int iLimit = 0;                 /* Zero values greater than this */
60881   iLimit = pWal->hdr.mxFrame - sLoc.iZero;
60882   assert( iLimit>0 );
60884     if( sLoc.aHash[i]>iLimit ){
60892   nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit+1]);
60893   memset((void *)&sLoc.aPgno[iLimit+1], 0, nByte);
60899   if( iLimit ){
60902     for(j=1; j<=iLimit; j++){
61331 SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){
61332   if( pWal ) pWal->mxWalSize = iLimit;
77545   int iLimit;         /* Maximum allowed string or blob size */
77558     iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
77560     iLimit = SQLITE_MAX_LENGTH;
77568       for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
77582     if( nByte>iLimit ){
77623   if( nByte>iLimit ){
102278     pNew->iLimit = 0;
102525 ** If the expression list pEList contains more than iLimit elements,
103605       pSelect->iLimit = 0;
103791   pSel->iLimit = 0;
128279     i64 iLimit = -2;
128281       sqlite3DecOrHexToI64(zRight, &iLimit);
128282       if( iLimit<-1 ) iLimit = -1;
128284     iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
128285     returnSingleInt(v, iLimit);
128352     int iLimit, addr;
128353     if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
128354       iLimit = 0x7fffffff;
128357     sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
131304   pNew->iLimit = 0;
131765   int iLimit;                        /* LIMIT counter */
131792   assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
131793   iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
131838     if( iLimit ){
131839       sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
131846   if( iLimit ){
131863     sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
132156     if( p->iLimit
132452   if( pSort==0 && p->iLimit ){
132453     sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
133328 ** Compute the iLimit and iOffset fields of the SELECT based on the
133331 ** keywords.  Or NULL if those keywords are omitted. iLimit and iOffset
133334 ** iLimit and iOffset are negative.
133336 ** This routine changes the values of iLimit and iOffset only if
133337 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight.  iLimit
133342 ** of the OFFSET.  The iLimit register is initialized to LIMIT.  Register
133352   int iLimit = 0;
133357   if( p->iLimit ) return;
133368     p->iLimit = iLimit = ++pParse->nMem;
133372       sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
133381       sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
133382       sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
133384       sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
133392       sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
133538   regLimit = p->iLimit;
133541   p->iLimit = p->iOffset = 0;
133824         pPrior->iLimit = p->iLimit;
133833         p->iLimit = pPrior->iLimit;
133835         if( p->iLimit ){
133836           addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
133840                               p->iLimit, p->iOffset+1, p->iOffset);
133926         p->iLimit = 0;
134121 ** If the LIMIT found in p->iLimit is reached, jump immediately to
134234   if( p->iLimit ){
134235     sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
134359   int savedLimit;       /* Saved value of p->iLimit */
134471   if( p->iLimit && op==TK_ALL ){
134474     sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
134498   pPrior->iLimit = regLimitA;
134510   savedLimit = p->iLimit;
134512   p->iLimit = regLimitB;
134516   p->iLimit = savedLimit;
137677   if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
143783   LogEst iLimit;            /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */
152426   if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 && pWInfo->iLimit<nRow ){
152427     nRow = pWInfo->iLimit;
153143   pWInfo->iLimit = iAuxArg;
221195     int iLimit;
221203     iLimit = (iOff>9 ? iOff-9 : 0);
221204     for(iOff--; iOff>iLimit; iOff--){