Lines Matching defs:limit
773 #define SQLITE_TOOBIG 18 /* String or BLOB exceeds size limit */
1199 ** current limit. Otherwise the limit is set to the larger of the value
1201 ** pointed to is set to the new limit.
1369 ** pointer is overwritten with the old value. The limit is not changed if
1370 ** the value originally pointed to is negative, and so the current limit
2356 ** that are the default mmap size limit (the default setting for
2357 ** [PRAGMA mmap_size]) and the maximum allowed mmap size limit.
3555 ** The [SQLITE_TRACE_SIZE_LIMIT] compile-time option can be used to limit
4263 ** [database connection] whose limit is to be set or queried. The
4264 ** second parameter is one of the [limit categories] that define a
4266 ** new limit for that construct.)^
4268 ** ^If the new limit is a negative number, the limit is unchanged.
4269 ** ^(For each limit category SQLITE_LIMIT_<i>NAME</i> there is a
4274 ** ^Attempts to increase a limit above its hard upper bound are
4277 ** ^Regardless of whether or not the limit was changed, the
4278 ** [sqlite3_limit()] interface returns the prior value of the limit.
4279 ** ^Hence, to find the current value of a limit without changing it,
4295 ** New run-time limit categories may be added in future releases.
4301 ** KEYWORDS: {limit category} {*limit categories}
5542 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
5549 ** aggregate may take any number of arguments between 0 and the limit
7071 ** soft limit on the amount of heap memory that may be allocated by SQLite.
7073 ** limit by reducing the number of pages held in the page cache
7074 ** as heap memory usages approaches the limit.
7075 ** ^The soft heap limit is "soft" because even though SQLite strives to stay
7076 ** below the limit, it will exceed the limit rather than generate
7077 ** an [SQLITE_NOMEM] error. In other words, the soft heap limit
7084 ** when the hard heap limit is reached.
7088 ** the heap limit prior to the call, or negative in the case of an
7090 ** then no change is made to the heap limit. Hence, the current
7096 ** ^The soft heap limit may not be greater than the hard heap limit.
7097 ** ^If the hard heap limit is enabled and if sqlite3_soft_heap_limit(N)
7098 ** is invoked with a value of N that is greater than the hard heap limit,
7099 ** the soft heap limit is set to the value of the hard heap limit.
7100 ** ^The soft heap limit is automatically enabled whenever the hard heap
7101 ** limit is enabled. ^When sqlite3_hard_heap_limit64(N) is invoked and
7102 ** the soft heap limit is outside the range of 1..N, then the soft heap
7103 ** limit is set to N. ^Invoking sqlite3_soft_heap_limit64(0) when the
7104 ** hard heap limit is enabled makes the soft heap limit equal to the
7105 ** hard heap limit.
7114 ** <li> The limit value is set to zero.
11328 ** CAPI3REF: Return An Upper-limit For The Size Of The Changeset
11336 ** When enabled, this function returns an upper limit, in bytes, for the size
13156 ** There is no limit to the number of synonyms that may be provided for a
13309 ** The hard limit is the ability of a 32-bit signed integer
13327 ** The hard upper limit here is 32676. Most database people will
13341 ** turn the limit off. That is no longer true. It is not possible
13342 ** to turn this limit off.
13352 ** expression. A value of 0 means that there is no limit.
13364 ** any limit on the number of terms in a compount SELECT.
13427 /* Maximum page size. The upper bound on this value is 65536. This a limit
13433 ** compiled with a different limit. If a process operating on a database
13435 ** compiled with the default page-size limit will not be able to rollback
15189 ** value means no limit. This value may be overridden using the
16628 ** If no global maximum is configured, then the system attempts to limit
19438 Pgno mxPage; /* Maximum page number. 0 for no limit. */
27056 ** it is not actually possible to reach this limit.
29077 ** Default value of the hard heap limit. 0 means "no limit".
29088 sqlite3_int64 alarmThreshold; /* The soft heap limit */
29126 ** Set the soft heap-size limit for the library. An argument of
29127 ** zero disables the limit. A negative argument is a no-op used to
29130 ** The return value is the value of the heap limit just before this
29133 ** If the hard heap limit is enabled, then the soft heap limit cannot
29134 ** be disabled nor raised above the hard heap limit.
29167 ** Set the hard heap-size limit for the library. An argument of zero
29168 ** disables the hard heap limit. A negative argument is a no-op used
29169 ** to obtain the return value without affecting the hard heap limit.
29171 ** The return value is the value of the hard heap limit just prior to
29174 ** Setting the hard heap limit will also activate the soft heap limit
29175 ** and constrain the soft heap limit to be no more than the hard heap
29176 ** limit.
29218 ** words if the amount of heap used is close to the limit set by
29317 ** This is not a limit on the total amount of memory used. This is
29318 ** a limit on the size parameter to sqlite3_malloc() and sqlite3_realloc().
29559 /* The 0x7ffff00 limit term is explained in comments on sqlite3Malloc() */
30143 ** Hard limit on the precision of floating-point conversions.
34809 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.
43811 ** * conch file to limit access to the database file to a single host
52989 ** and without exceeding the cache size limit.
53033 ** size limit has been reached, then this routine can be invoked to
54346 ** Configure the cache_size limit for a cache.
55908 ** such a system. This is currently an undocumented limit.
56085 ** The dbHintSize variable is used to limit the number of calls made to
56181 i64 journalSizeLimit; /* Size limit for persistent journal files */
56917 ** is still held on the file. If there is a size limit configured for
56919 ** space than that limit allows for, truncate it now. There is no need
58819 ** configured maximum pager number, increase the allowed limit so
60100 ** soft memory limit. The first argument is a pointer to a Pager object
63006 ** Get/set the size-limit used for persistent journal files.
63008 ** Setting the size limit to -1 means no limit is enforced.
63009 ** An attempt to set a limit smaller than -1 is a no-op.
65596 sqlite3_log(rx, "cannot limit WAL size: %s", pWal->zWalName);
67163 ** journal size limit, if possible.
67659 ** is to limit the maximum cell size so that at least 4 cells will fit
71515 ** Change the "soft" limit on the number of pages in the cache.
71517 ** pages in the cache exceeds this soft limit. But the size of the
71518 ** cache is allowed to grow larger than this limit if it contains
71531 ** Change the "spill" limit on the number of pages in the cache.
71532 ** If the number of pages exceeds this limit during a write transaction,
71552 ** Change the limit on the amount of the database file that may be
76682 int limit = pOld->nCell;
76714 memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
76716 if( NEVER(limit<pOld->aiOvfl[0]) ){
76720 limit = pOld->aiOvfl[0];
76721 for(j=0; j<limit; j++){
80523 /* 0x7FFFFFFF is the hard limit for the number of pages in a database
81673 ** size limit) then no memory allocation occurs. If the string can be
86755 ** limit given by pKeyInfo->nAllField.
87463 ** limit the size of the header to 64 bytes in cases where the first field
87466 ** The easiest way to enforce this limit is to consider only records with
95742 int cnt; /* Counter to limit the number of searches */
97722 ** LIMIT and OFFSET processing. r[P1] holds the limit counter. r[P3]
97750 ** it would take nearly 300 years to actually reach the limit. So
99862 ** records to a PMA is roughly the same as the limit configured for the
99928 ** to a level 0 PMA. The purpose of this limit is to prevent various integer
100095 int mxPmaSize; /* Maximum PMA size, in bytes. 0==no limit */
100722 /* Initialize the upper limit on the number of worker threads */
109070 Expr *pLimit; /* New limit expression */
109121 ** preexisting limit is discarded in place of the new LIMIT 1.
109140 /* The subquery already has a limit. If the pre-existing limit is X
109141 ** then make the new limit X<>0 so that the new limit is either 1 or 0 */
109152 /* If there is no pre-existing limit add a limit of 1 */
114891 int nLimit; /* Analysis row-scan limit */
114990 ** L: A limit on the number of rows to scan, or 0 for no-limit
123900 ** is a limit/offset term to enforce.
123906 /* Generate a select expression tree to enforce the limit/offset
132132 int (*limit)(sqlite3*,int,int);
132477 #define sqlite3_limit sqlite3_api->limit
133217 ** an oversize filename. Most filesystems have a pathname limit of 4K,
133218 ** so limit the extension filename length to about twice that.
134987 ** Get or set the size limit on rollback journal files.
135149 ** Used to set mapping size limit. The mapping size limit is
135150 ** used to limit the aggregate size of all memory mapped regions of the
135153 ** limit determined by sqlite3_config(SQLITE_CONFIG_MMAP_SIZE) is set.
136682 ** limit. The hard heap limit can be activated or lowered by this
136685 ** the hard heap limit. This allows an application to set a heap limit
136722 ** in each index that it looks at. Return the new limit.
140637 ** the limit and offset. If there is no limit and/or offset, then
140641 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
140649 ** Only if pLimit->pLeft!=0 do the limit registers get
140651 ** the reuse of the same limit and offset registers across multiple
140692 pParse->nMem++; /* Allocate an extra register for limit+offset */
140977 ** Since the limit is exactly 1, we only need to evaluate the left-most VALUES.
141799 /* Compute the limit registers */
142885 ** does not work if either limit is negative.
145241 ** an exact limit.
151738 /* The WhereLoopBuilder.iPlanLimit is used to limit the number of
151742 ** routine. The limit is high enough that is should not impact real-world
151745 ** SQLITE_QUERY_PLANNER_LIMIT is the baseline limit. The limit is
151749 ** baseline limit was exhausted by prior tables of the join.
156250 int iReg, /* Register that will hold value of the limit/offset */
156251 Expr *pExpr, /* Expression that defines the limit/offset */
158491 /* TUNING: If there is both an upper and lower limit and neither limit
159040 /* Stop the search once we hit the query planner search limit */
159042 WHERETRACE(0xffffffff,("=== query planner search limit reached ===\n"));
160874 /* We hit the query planner search limit set by iPlanLimit */
162132 ** Terms of the WHERE clause are also used to limit which rows actually
162180 ** If WHERE_USE_LIMIT, then the limit amount */
162371 sqlite3DebugPrintf(", limit: %d", iAuxArg);
174073 ** integer (sqlite3_int64) values that are the default mmap size limit
174075 ** mmap size limit. */
176198 ** This array defines hard upper bounds on limit values. The
176256 ** Change the value of a limit. Report the old value.
176257 ** If an invalid limit index is supplied, report -1.
176259 ** new limit is negative.
176261 ** A new lower limit does not shrink existing constructs.
176262 ** It merely prevents new constructs that exceed the limit
176275 /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
176485 int limit = 0;
176496 limit = mask;
176511 limit = mask & flags;
176530 if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
179327 ** limit is that it may allow very large queries to use large amounts
179347 ** However if this limit is reached midway through a transaction, a new
179534 int nNodeSize; /* Soft limit for node size */
184725 ** for-loop. Except, limit the value to 2^24 to prevent it from
189938 ** The code is written so that the hard lower-limit for each of these values
190227 /* Estimate the upper limit on the number of leaf nodes in a new segment
194857 ** no levels with more than nMin segments. Use this to limit the
198387 ** This limit is needed to avoid a stack overflow in the recursive
208623 ** Configure a limit for the amount of temp space that may be used by
208624 ** the RBU handle passed as the first argument. The new limit is specified
208625 ** in bytes by the second parameter. If it is positive, the limit is updated.
208626 ** If the second parameter to this function is passed zero, then the limit
208627 ** is removed entirely. If the second parameter is negative, the limit is
208628 ** not modified (this is useful for querying the current limit).
208630 ** In all cases the returned value is the current limit in bytes (zero
208633 ** If the temp space limit is exceeded during operation, an SQLITE_FULL
209220 i64 szTempLimit; /* Total size limit for temp files */
209384 unsigned int limit;
209390 limit = rbuDeltaGetInt(&zDelta, &lenDelta);
209409 if( total>limit ){
209424 if( total>limit ){
209447 if( total!=limit ){
214165 ** Configure the aggregate temp file size limit for this RBU handle.
217526 ** allocate up to this limit - instead of up to the largest power of
217527 ** two smaller than the limit. */
218609 /* The hard upper limit for the number of columns in an SQLite
221817 ** There is no limit to the number of synonyms that may be provided for a
221993 /* Truncate very long tokens to this many bytes. Hard limit is
236986 ** limit of rowids to return, and iLastRowid the upper. In other words, the
236992 ** is the upper limit (i.e. the "first" rowid visited) and iLastRowid
243185 ** Objects are rarely larger than 2MiB limit of a 3-byte varint.