Lines Matching refs:iLimit
9156 ** to the value of the iLimit parameter passed to xTruncate(). If any
9186 void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
9207 void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
18811 ** detailed description of the meaning of the iLimit and iOffset fields.
18827 int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
42757 int iLimit = 0;
42779 if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ){
51744 sqlite3_int64 iLimit = *(sqlite3_int64*)pArg;
51745 if( iLimit<p->sz ){
51746 if( iLimit<0 ){
51747 iLimit = p->szMax;
51749 iLimit = p->sz;
51752 p->szMax = iLimit;
51753 *(sqlite3_int64*)pArg = iLimit;
54175 ** greater than or equal to iLimit. Any pinned pages that meet this
54182 unsigned int iLimit /* Drop pages with this pgno or larger */
54187 assert( pCache->iMaxKey >= iLimit );
54189 if( pCache->iMaxKey - iLimit < pCache->nHash ){
54194 h = iLimit % pCache->nHash;
54209 if( pPage->iKey>=iLimit ){
54687 ** or greater than parameter iLimit. Any pinned pages with a page number
54688 ** equal to or greater than iLimit are implicitly unpinned.
54690 static void pcache1Truncate(sqlite3_pcache *p, unsigned int iLimit){
54693 if( iLimit<=pCache->iMaxKey ){
54694 pcache1TruncateUnsafe(pCache, iLimit);
54695 pCache->iMaxKey = iLimit-1;
56903 const i64 iLimit = pPager->journalSizeLimit; /* Local cache of jsl */
56906 if( doTruncate || iLimit==0 ){
56922 if( rc==SQLITE_OK && iLimit>0 ){
56925 if( rc==SQLITE_OK && sz>iLimit ){
56926 rc = sqlite3OsTruncate(pPager->jfd, iLimit);
63011 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *pPager, i64 iLimit){
63012 if( iLimit>=-1 ){
63013 pPager->journalSizeLimit = iLimit;
63014 sqlite3WalLimit(pPager->pWal, iLimit);
64434 int iLimit = 0; /* Zero values greater than this */
64457 iLimit = pWal->hdr.mxFrame - sLoc.iZero;
64458 assert( iLimit>0 );
64460 if( sLoc.aHash[i]>iLimit ){
64468 nByte = (int)((char *)sLoc.aHash - (char *)&sLoc.aPgno[iLimit]);
64470 memset((void *)&sLoc.aPgno[iLimit], 0, nByte);
64476 if( iLimit ){
64479 for(j=0; j<iLimit; j++){
64937 SQLITE_PRIVATE void sqlite3WalLimit(Wal *pWal, i64 iLimit){
64938 if( pWal ) pWal->mxWalSize = iLimit;
81693 int iLimit; /* Maximum allowed string or blob size */
81708 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
81710 iLimit = SQLITE_MAX_LENGTH;
81717 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
81726 if( nByte>iLimit ){
107552 pNew->iLimit = 0;
107828 ** If the expression list pEList contains more than iLimit elements,
108959 pSelect->iLimit = 0;
109156 pSel->iLimit = 0;
134991 i64 iLimit = -2;
134993 sqlite3DecOrHexToI64(zRight, &iLimit);
134994 if( iLimit<-1 ) iLimit = -1;
134996 iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
134997 returnSingleInt(v, iLimit);
135064 int iLimit = 0, addr;
135065 if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
135066 iLimit = 0x7fffffff;
135069 sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
138357 pNew->iLimit = 0;
138914 int iLimit; /* LIMIT counter */
138941 assert( pSelect->iOffset==0 || pSelect->iLimit!=0 );
138942 iLimit = pSelect->iOffset ? pSelect->iOffset+1 : pSelect->iLimit;
138987 if( iLimit ){
138988 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, pSort->labelDone);
138995 if( iLimit ){
139012 sqlite3VdbeAddOp2(v, OP_IfNotZero, iLimit, sqlite3VdbeCurrentAddr(v)+4);
139343 if( p->iLimit ){
139344 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak);
139454 if( p->iLimit
139481 if( p->iLimit ){
139482 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak);
139715 if( pSort==0 && p->iLimit ){
139716 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
139934 assert( p->iLimit==0 && p->iOffset==0 );
139955 sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
140632 ** Compute the iLimit and iOffset fields of the SELECT based on the
140635 ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
140638 ** iLimit and iOffset are negative.
140640 ** This routine changes the values of iLimit and iOffset only if
140641 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
140646 ** of the OFFSET. The iLimit register is initialized to LIMIT. Register
140656 int iLimit = 0;
140661 if( p->iLimit ) return;
140672 p->iLimit = iLimit = ++pParse->nMem;
140676 sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
140685 sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
140686 sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); VdbeCoverage(v);
140688 sqlite3VdbeAddOp2(v, OP_IfNot, iLimit, iBreak); VdbeCoverage(v);
140696 sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
140842 regLimit = p->iLimit;
140845 p->iLimit = p->iOffset = 0;
141127 pPrior->iLimit = p->iLimit;
141137 p->iLimit = pPrior->iLimit;
141139 if( p->iLimit ){
141140 addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
141144 p->iLimit, p->iOffset+1, p->iOffset);
141233 p->iLimit = 0;
141435 ** If the LIMIT found in p->iLimit is reached, jump immediately to
141548 if( p->iLimit ){
141549 sqlite3VdbeAddOp2(v, OP_DecrJumpZero, p->iLimit, iBreak); VdbeCoverage(v);
141675 int savedLimit; /* Saved value of p->iLimit */
141801 if( p->iLimit && op==TK_ALL ){
141804 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
141828 pPrior->iLimit = regLimitA;
141840 savedLimit = p->iLimit;
141842 p->iLimit = regLimitB;
141846 p->iLimit = savedLimit;
145468 if( p->iLimit==0 && sSort.addrSortIndex>=0 ){
151782 LogEst iLimit; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */
156335 whereAddLimitExpr(pWC, p->iLimit, p->pLimit->pLeft,
161306 if( (pWInfo->wctrlFlags & WHERE_USE_LIMIT)!=0 && pWInfo->iLimit<nRow ){
161307 nRow = pWInfo->iLimit;
162254 pWInfo->iLimit = iAuxArg;
231450 int iLimit;
231458 iLimit = (iOff>9 ? iOff-9 : 0);
231459 for(iOff--; iOff>iLimit; iOff--){