Lines Matching defs:length
1625 ** structure used by this VFS. mxPathname is the maximum length of
1777 int mxPathname; /* Maximum file pathname length */
3250 ** of memory at least N bytes in length, where N is the parameter.
3556 ** the length of [bound parameter] expansion in the output of sqlite3_trace().
4313 ** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
4340 ** <dd>The maximum length of the pattern argument to the [LIKE] or
4510 int nByte, /* Maximum length of zSql in bytes. */
4517 int nByte, /* Maximum length of zSql in bytes. */
4524 int nByte, /* Maximum length of zSql in bytes. */
4532 int nByte, /* Maximum length of zSql in bytes. */
4539 int nByte, /* Maximum length of zSql in bytes. */
4546 int nByte, /* Maximum length of zSql in bytes. */
4577 ** the maximum string length determined by the [SQLITE_LIMIT_LENGTH].
4803 ** is negative, then the length of the string is
4841 ** ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
4847 ** ^A negative value for the zeroblob results in a zero-length BLOB.
5337 ** value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
5540 ** redefined. ^The length of the name is limited to 255 bytes in a UTF-8
5542 ** length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
6203 ** the string length itself by searching the 2nd parameter for the first
6352 ** function callback are the length of the two strings, in bytes. The collating
8526 ** length of the string contained in the [sqlite3_str] object will be
8573 ** inside [sqlite3_str] object X back to zero bytes in length.
8599 ** ^The [sqlite3_str_length(X)] method returns the current length, in bytes,
8601 ** ^The length returned by [sqlite3_str_length(X)] does not include the
9611 ** a fixed-length buffer on the stack. If the log message is longer than
9612 ** a few hundred characters, it will be truncated to the length of the
9778 ** ^If parameter zDb is NULL or points to a zero length string, then the
9792 ** zDb is not NULL (or a zero length string) and is not the name of any
11174 ** rows a zero-length blob (SQL value X'') is stored in the changeset or
11180 ** zero-length blob back to a NULL value when updating the sqlite_stat1
13306 ** The maximum length of a TEXT or BLOB in bytes. This also
13338 ** The maximum length of a single SQL statement in bytes.
13483 ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
14980 /* Maximum pathname length. Note: FILENAME_MAX defined by stdio.h
15713 ** nKey the ROWID length of pKey
15717 ** nData length of pData not used
17364 #define SQLITE_FUNC_LENGTH 0x0040 /* Built-in length() function */
19282 #define OPFLAG_LENGTHARG 0x40 /* OP_Column only used for length() */
19478 int mxStrlen; /* Maximum string length */
20440 ** Routines to read and write variable-length integers. These used to
22365 ** sqlite3StdTypeLen[] The length (in bytes) of each entry
22663 ** length Mem.n. Zero-terminated if
22669 ** * MEM_Blob A blob, stored in Mem.z length Mem.n.
22673 ** * MEM_Blob|MEM_Zero A blob in Mem.z of length Mem.n plus
30160 int length; /* Length of the field */
30431 length = (int)(&zOut[nOut-1]-bufpt);
30432 while( precision>length ){
30434 length++;
30437 int nn = (length - 1)/3; /* Number of "," to insert */
30438 int ix = (length - 1)%3 + 1;
30457 length = (int)(&zOut[nOut-1]-bufpt);
30468 length = 0;
30500 length = 3;
30515 length = 3+(prefix!=0);
30613 length = (int)(bufpt-zOut);
30618 if( flag_zeropad && !flag_leftjustify && length < width){
30620 int nPad = width - length;
30626 length = width;
30634 length = width = 0;
30639 length = 1;
30644 length = 1;
30648 while( length<4 && (bufpt[0]&0xc0)==0x80 ){
30649 buf[length++] = *(bufpt++);
30659 length = 1;
30663 length = 2;
30668 length = 3;
30674 length = 4;
30684 sqlite3_str_append(pAccum, buf, length);
30715 length = 0;
30722 /* Set length to the number of bytes needed in order to display
30728 length = (int)(z - (unsigned char*)bufpt);
30730 for(length=0; length<precision && bufpt[length]; length++){}
30733 length = 0x7fffffff & (int)strlen(bufpt);
30738 int ii = length - 1;
30787 length = j;
30808 length = width = 0;
30835 length = width = 0;
30845 ** "length" characters long. The field width is "width". Do
30846 ** the output. Both length and width are in bytes, not characters,
30851 width -= length;
30854 sqlite3_str_append(pAccum, bufpt, length);
30857 sqlite3_str_append(pAccum, bufpt, length);
31084 /* Return the current length of p in bytes */
33192 ** * This routine accepts over-length UTF8 encodings
33193 ** for unicode values 0x80 and greater. It does not change over-length
33244 sqlite3_int64 len; /* Maximum length of output string in bytes */
33671 ** Compute a string length that is limited to what can be stored in
33675 ** than the actual length of the string. For very long strings (greater
33676 ** than 1GiB) the value returned might be less than the true string length.
33835 ** The return value is -1 if no dequoting occurs or the length of the
34011 ** The string z[] is length bytes in length (bytes, not characters) and
34039 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
34056 if( length==0 ) return 0;
34060 zEnd = z + length;
34064 length &= ~1;
34068 for(i=3-enc; i<length && z[i]==0; i+=2){}
34069 if( i<length ) eType = -100;
34226 return !sqlite3Atoi64(z, pResult, length, enc);
34300 ** length is the number of bytes in the string (bytes, not characters).
34304 SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
34313 const char *zEnd = zNum + length;
34319 length &= ~1;
34321 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
34322 nonNum = i<length;
34521 ** The variable-length integer encoding is as follows:
34540 ** Write a 64-bit variable-length integer to memory starting at p[0].
34541 ** The length of data write will be between 1 and 9 bytes. The number
34544 ** A variable-length integer consists of the lower 7 bits of each byte
34600 ** Read a 64-bit variable-length integer from memory starting at p[0].
34754 ** Read a 32-bit variable-length integer from memory starting at p[0].
36120 ** nData+1 bytes in length.
36122 ** Return the actual length of the encoded text, not counting the
36188 ** written into pOut, which must be at least nOut bytes in length.
36947 ** Maximum supported path-length.
37745 ** Changes are made in-place. Return the new name length.
39618 unsigned long long length; /* nbr of bytes to lock */
39637 unsigned long long length, /* Number of bytes to lock */
39646 pb.length = length;
39651 offset, length));
40662 ** normal database file) and we truncate the file to zero length,
40664 ** when restoring a database using the backup API from a zero-length
41471 ** the file must be truncated to zero length or have its header cleared.
43903 ** which must point to valid, writable memory large enough for a maxLen length
44078 #define PROXY_HOSTIDLEN 16 /* conch file host id length */
44118 #define PROXY_HEADERLEN 1 /* conch file header length */
45189 ** Maximum pathname length (in chars) for Win32. This should normally be
45204 ** Maximum pathname length (in chars) for WinNT. This should normally be
45212 ** Maximum pathname length (in bytes) for Win32. The MAX_PATH macro is in
45221 ** Maximum pathname length (in bytes) for WinNT. This should normally be
45230 ** Maximum error message length (in chars) for WinRT.
48992 ** the file must be truncated to zero length or have its header cleared.
50087 sqlite3_vfs *pVfs, /* Used to get maximum path length and AppData */
50546 /* For an SQLITE_ACCESS_EXISTS query, treat a zero-length file
52207 ** This file implements an object that represents a fixed-length
55545 ** in length and are aligned on a page boundary.
55548 ** an integer multiple of the page size in length or are taken from the
57181 ** + 4 bytes: N (length of super-journal name in bytes, no nul-terminator).
57210 /* Calculate the length in bytes and the checksum of zSuper */
60293 ** to by zPathname, length nPathname. Or, if this is a temporary file,
60326 ** bytes in length. This means the database cannot be opened,
67731 ** Cells are of variable length. Cells are stored in the cell content area at
67736 ** Cell content makes use of variable length integers. A variable
67737 ** length integer is 1 to 9 bytes where the lower 7 bits of each
67740 ** appears first. A variable-length integer may not be more than 9 bytes long.
67752 ** Variable length integers are used for rowids and to hold the number of
70036 /* pIter now points at the 64-bit integer key value, a variable length
76258 ** byte page number followed by a variable length integer. In other
76324 ** a variable length key value (which must be the same value as the
76329 ** record-length (a variable length integer at most 32-bits in size)
76330 ** and the key value (a variable length integer, may have any value).
76331 ** The first of the while(...) loops below skips over the record-length
78955 isFreeList ? "size" : "overflow list length",
79601 ** change the length of the data stored. If this function is called with
81427 ** Delete any previous value and set the value to be a BLOB of length
82634 ** zId of length nId is a double-quoted identifier. Check to see if
85369 ** If the return value of sqlite3BtreeGetFilename() is a zero length
86350 ** Return the length of the data corresponding to the supplied serial-type.
86550 ** length.
86552 ** (N-13)/2 bytes in length. */
90767 ** into buffer zBuf, length nBuf.
91583 ** this transformation, the length of string P4 is computed and stored
91621 ** The string value P4 of length P1 (bytes) is stored in register P2.
92656 ** The first integer in the P4 integer array is the length of the array
93164 ** to only be used by the length() function or the equivalent. The content
93175 int len; /* The length of the serialized data for the column */
93263 ** them, respectively. So the maximum header length results from a
93265 ** extra bytes for the header length itself. 32768*3 + 3 = 98307.
93422 ** 2. the length(X) function if X is a blob, and
93423 ** 3. if the content length is zero.
94688 ** can be used as zero-length data for OP_Insert. This is an optimization
94714 ** form sqlite3BtreeInsert() where the length of the data is zero. */
100498 ** contains a single PMA, and that that PMA omits the initial length varint.
110325 /* For length() and typeof() functions with a column argument,
112746 " || substr(sql,1+length(printf('%%.%ds',sql))) "
118349 testcase( zTabName[0]==0 ); /* Zero-length table names are allowed */
119103 ** Scan the column type name zType (length nType) and return the
123176 ** in the encoding enc of name zName, length nName.
123351 ** collation sequence with name zName, length nName.
123354 ** db for collation type name zName, length nName, or NULL, if no collation
124830 ** Implementation of the length() function
125160 ** If nByte is larger than the maximum string or blob length, then
125611 /* Limit the length of the LIKE or GLOB pattern to avoid problems
126478 int nFirstSepLength; /* Used to detect separator length change */
126482 ** If pnSepLengths==0, nFirstSepLength is the length used throughout.
126526 /* First separator length variation seen, start tracking them. */
126687 ** operator if c is a string literal that is exactly one byte in length.
127000 FUNCTION2(length, 1, 0, 0, lengthFunc, SQLITE_FUNC_LENGTH),
133218 ** so limit the extension filename length to about twice that.
151506 ** The "solver" works by creating the N best WherePath objects of length
151508 ** of length 2. And so forth until the length of WherePaths equals the
166341 ** all elements in the list. And make sure list length does not exceed
171924 /* aKWLen[i] is the length (in bytes) of the i-th keyword */
172119 ** return the integer n (the length of the token). */
172434 ** Return the length (in bytes) of the token that begins at z[0].
172738 int mxSqlLen; /* Max length of an SQL string */
172907 int n; /* length of current token */
175910 ** to contains a zero-length string, all attached databases are
178737 ** The basic unit of encoding is a variable-length integer called a
178738 ** varint. We encode variable-length integers in little-endian order
178752 ** are are limited to 9 bytes in length whereas FTS3 varints are
178753 ** little-endian and can be up to 10 bytes in length (in theory).
178826 ** varint nTerm; (length of first term)
178828 ** varint nDoclist; (length of term's associated doclist)
178832 ** varint nPrefix; (length of prefix shared with previous term)
178833 ** varint nSuffix; (length of unshared suffix)
178835 ** varint nDoclist; (length of term's associated doclist)
178874 ** varint nTerm; (length of first term)
178878 ** varint nPrefix; (length of shared prefix with previous term)
178879 ** varint nSuffix; (length of unshared suffix)
179153 ** stemming has been performed). *pnBytes should be set to the length
179368 ** Maximum length of a varint encoded integer. The varint format is different
179369 ** from that used by SQLite, so the maximum length is 10, not 9.
179553 ** is an index of prefixes of a specific length.
179563 int nPrefix; /* Prefix length (0 for main terms index) */
179974 ** Write a 64-bit variable-length integer to memory starting at p[0].
179975 ** The length of data written will be between 1 and FTS3_VARINT_MAX bytes.
180020 ** Read a 64-bit variable-length integer from memory starting at p[0].
180029 ** Read a 64-bit variable-length integer from memory starting at p[0] and
183800 ** there exists prefix b-tree of the right length) then it may be traversed
184126 int *pnList, /* OUT: List length pointer */
184902 ** FTs3Expr.pPhrase->doclist.nList (length of pList in bytes)
185793 int nStop; /* Byte-length of string zStop */
186484 ** Extract the next token from buffer z (length n) using the tokenizer
186583 ** Buffer zInput, length nInput, contains the contents of a quoted string
186922 ** Parse the fts3 query expression found in buffer z, length n. This function
187320 ** Parameters z and n contain a pointer to and length of a buffer containing
187329 ** nul-terminated string and the length is determined using strlen().
188339 ** Stemming never increases the length of the word. So there is
190720 ** Tokens must have a non-zero length.
191357 ** *pnOffsetList is set to the length of the set of column-offset
191928 int nSuffix; /* Suffix length */
191957 /* There is no prefix-length field for first term in a node */
192498 ** function adjusts the pointer *ppList and the length *pnList so that they
194176 /* Check for the zero-length marker in the %_segments table */
195769 int nSnippet; /* Requested snippet length (in tokens) */
196221 int nSnippet, /* Desired snippet length */
196302 ** If nAppend is negative, then the length of the string zAppend is
196967 const char *a; /* Aggregate column length array */
196968 const char *pEnd; /* First byte past end of length array */
197172 /* Limit the snippet length to 64 tokens. */
203047 ** Return the margin length of cell p. The margin length is the sum
204638 "SELECT length(data) FROM '%q'.'%q_node' WHERE nodeno = 1",
204657 ** Return the length of a token
207420 ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
207568 /* Limit the length of the LIKE or GLOB pattern to avoid problems
209293 ** the integer. The *pLen parameter holds the length of the string
209366 ** binary files) so we also have to pass in the length of the delta in
216671 ** sqlite_stat1 table. The purpose of this is to substitute a zero-length
219411 "WHEN length(?4)=0 AND typeof(?4)='blob' THEN NULL "
219610 "CASE WHEN length(?2)=0 AND typeof(?2)='blob' THEN NULL ELSE ?2 END, "
219617 "CASE WHEN length(?2)=0 AND typeof(?2)='blob' THEN NULL ELSE ?2 END "
224647 ** bytes in length instead of a NULL pointer.
224872 /* Calculate the average document length for this FTS5 table */
225273 ** is non-negative, then it is the length of the string in bytes. Otherwise,
225274 ** the length of the string is determined using strlen().
225689 *pzErr = sqlite3_mprintf("prefix length out of range (max 999)");
233719 ** (pNew/<length-unknown>) shares with buffer (pOld/nOld).
233721 ** Buffer (pNew/<length-unknown>) is guaranteed to be greater
243218 ** Read a 64-bit variable-length integer from memory starting at p[0].
243381 ** The variable-length integer encoding is as follows:
243406 ** Write a 64-bit variable-length integer to memory starting at p[0].
243407 ** The length of data write will be between 1 and 9 bytes. The number
243410 ** A variable-length integer consists of the lower 7 bits of each byte