Lines Matching refs:string
433 ** evaluates to a string literal that is the SQLite version in the
448 ** a string which identifies a particular check-in of SQLite
450 ** string contains the date and time of the check-in (UTC) and a SHA1
481 ** ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
483 ** to the sqlite3_version[] string constant. The sqlite3_libversion()
485 ** direct access to string constants within the DLL. ^The
488 ** a pointer to a string constant whose value is the same as the
510 ** returning the N-th compile time option string. ^If N is out of range,
700 ** sqlite3_exec() after the error message string is no longer needed.
713 ** result row is NULL then the corresponding string pointer for the
720 ** to an empty string, or a pointer that contains only whitespace and/or
1235 ** string containing the transactions super-journal file name. VFSes that
1327 ** of the char** argument point to a string obtained from [sqlite3_mprintf()]
1328 ** or the equivalent and that string will become the result of the pragma or
1334 ** prepared statement if result string is NULL, or that returns a copy
1335 ** of the result string if the string is non-NULL.
1378 ** The argument is a zero-terminated string. Higher layers in the
1646 ** is either a NULL pointer or string obtained
1652 ** the string will be valid and unchanged until xClose() is
2581 ** schema. ^The sole argument is a pointer to a constant UTF8 string
2583 ** does not make a copy of the new main schema name string, so the application
2689 ** the legacy [double-quoted string literal] misfeature for DML statements
2698 ** the legacy [double-quoted string literal] misfeature for DDL statements,
2999 ** SQLite for parsing. ^These routines return 1 if the input string
3003 ** string literals or quoted identifier names or comments are not
3021 ** UTF-8 string.
3024 ** UTF-16 string in native byte order.
3134 ** string representation as returned by [sqlite3_column_text()].
3168 ** string of its 2nd parameter and returns a result table to the
3211 ** memory to hold the resulting string.
3229 ** the zero terminator. So the longest string that can be completely
3419 ** is invoked once for that table with a column name that is an empty string.
3598 ** [prepared statement]. ^The X argument is a pointer to a string which
3825 ** ^If the filename is an empty string, then a private, temporary
3843 ** authority, then it must be either an empty string or the string
3844 ** "localhost". ^If the authority is not an empty string or "localhost", an
3866 ** an empty string the default VFS object is used. ^Specifying an unknown
4014 ** a pointer to an empty string.
4193 ** ^(Memory to hold the error message string is managed internally.
4195 ** However, the error string might be overwritten or deallocated by
4200 ** ^(Memory to hold the error message string is managed internally
4310 ** <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
4441 ** If the caller knows that the supplied string is nul-terminated, then
4443 ** is the number of bytes in the input string <i>including</i>
4454 ** string or a comment) then *ppStmt is set to NULL.
4561 ** string containing the SQL text of prepared statement P with
4564 ** string containing the normalized SQL text of prepared statement P. The
4572 ** the original string, "SELECT $abc,:xyz" but sqlite3_expanded_sql()
4577 ** the maximum string length determined by the [SQLITE_LIMIT_LENGTH].
4586 ** ^The string returned by sqlite3_expanded_sql(P), on the other hand,
4785 ** it should be a pointer to a well-formed unicode string that is
4803 ** is negative, then the length of the string is
4810 ** where the NUL terminator would occur assuming the string were NUL
4812 ** the value of the fourth parameter then the resulting string value will
4816 ** ^The fifth argument to the BLOB and string binding interfaces controls
4819 ** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
4820 ** with it may be passed. ^It is called to dispose of the BLOB or string even
4854 ** P. The T parameter should be a static string, preferably a string
4870 ** ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB
4923 ** have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
4933 ** nameless, then NULL is returned. ^The returned string is
4994 ** interface returns a pointer to a zero-terminated UTF-8 string
4996 ** UTF-16 string. ^The first parameter is the [prepared statement]
5000 ** ^The returned string pointer is valid until either the [prepared statement]
5026 ** either a UTF-8 or UTF-16 string. ^The _database_ routines return
5029 ** ^The returned string is valid until the [prepared statement] is destroyed
5077 ** ^The returned string is always UTF-8 encoded.
5087 ** this routine would return the string "VARIANT" for the second result
5217 ** <li> string
5307 ** If the result is a BLOB or a TEXT string, then the sqlite3_column_bytes()
5309 ** of that BLOB or string.
5311 ** ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
5312 ** routine returns the number of bytes in that BLOB or string.
5313 ** ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
5314 ** the string to UTF-8 and then returns the number of bytes.
5316 ** [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
5317 ** the number of bytes in that string.
5320 ** ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
5321 ** routine returns the number of bytes in that BLOB or string.
5322 ** ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
5323 ** the string to UTF-16 and then returns the number of bytes.
5325 ** [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
5326 ** the number of bytes in that string.
5331 ** of the string. ^For clarity: the values returned by
5333 ** bytes in the string, not the number of characters.
5394 ** need to be added to the string.</li>
5837 ** ^The sqlite3_value_text16() interface extracts a UTF-16 string
5864 ** words, if the value is a string that looks like a number)
6056 ** metadata associated with the pattern string.
6057 ** Then as long as the pattern string remains the same,
6153 ** ^SQLite uses the string pointed to by the
6156 ** message string from sqlite3_result_error() as UTF-8. ^SQLite
6157 ** interprets the string from sqlite3_result_error16() as UTF-16 using
6175 ** error indicating that a string or BLOB is too long to represent.
6193 ** a text string which is represented as UTF-8, UTF-16 native byte order,
6196 ** application-defined function to be a text string in an encoding
6203 ** the string length itself by searching the 2nd parameter for the first
6209 ** must be the byte offset into the string where the NUL terminator would
6210 ** appear if the string where NUL terminated. If any NUL characters occur
6211 ** in the string at a byte offset that is less than the value of the 3rd
6212 ** parameter, then the resulting string will contain embedded NULs and the
6232 ** string and the rest of the string is interpreted according to the
6265 ** string and preferably a string literal. The sqlite3_result_pointer()
6317 ** ^The name of the collation is a UTF-8 string
6319 ** and a UTF-16 string in native byte order for sqlite3_create_collation16().
6354 ** if the first string is less than, equal to, or greater than the second,
6522 ** ^(If this global variable is made to point to a string which is
6547 ** the [temp_store_directory pragma] always assumes that any string
6580 ** ^(If this global variable is made to point to a string which is
6604 ** the [data_store_directory pragma] always assumes that any string
6630 ** sqlite3_win32_set_directory interface except the string parameter must be
6696 ** Space to hold the string that is returned by sqlite3_db_name() is managed
6697 ** by SQLite itself. The string might be deallocated by any operation that
6701 ** remember the string long-term should make their own copy. Applications that
6716 ** this function will return either a NULL pointer or an empty string.
6718 ** ^The string value returned by this routine is owned and managed by
7705 ** string obtained from [sqlite3_mprintf()] to zErrMsg. The method should
7706 ** take care that any prior string is freed by a call to [sqlite3_free()]
7707 ** prior to assigning a new string to zErrMsg. ^After the error message
7708 ** is delivered up to the client application, the string will be automatically
8043 ** VFS is registered with a name that is NULL or an empty string,
8449 ** of bytes in the keyword into *L. The string that *Z points to is not
8489 ** KEYWORDS: {dynamic string}
8492 ** string under construction.
8499 ** <li> ^The sqlite3_str object is destroyed and the string it created
8526 ** length of the string contained in the [sqlite3_str] object will be
8538 ** that contains the constructed string. The calling application should
8541 ** errors were encountered during construction of the string. ^The
8543 ** string in [sqlite3_str] object X is zero bytes long.
8559 ** ^The [sqlite3_str_append(X,S,N)] method appends exactly N bytes from string S
8562 ** zero-terminated string in its entirety, use the [sqlite3_str_appendall()]
8566 ** zero-terminated string S onto the end of [sqlite3_str] object X.
8572 ** ^The [sqlite3_str_reset(X)] method resets the string under construction
8592 ** ^If any prior errors have occurred while constructing the dynamic string
8596 ** [SQLITE_TOOBIG] if the size of the dynamic string exceeds
8600 ** of the dynamic string under construction in [sqlite3_str] object X.
8605 ** content of the dynamic string under construction in X. The value
8610 ** object. ^Applications may change the content of the string returned
9558 ** string X matches the [GLOB] pattern P.
9575 ** string X matches the [LIKE] pattern P with escape character E.
9599 ** ^If logging is enabled, the zFormat string and subsequent arguments are
9600 ** used with [sqlite3_snprintf()] to generate the final output string.
9607 ** The zFormat string must not be NULL.
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
9975 ** method of a [virtual table]. This function returns a pointer to a string
10268 ** When the value returned to V is a string, space to hold that string is
10291 ** to a zero-terminated UTF-8 string containing the name of the index or table
10296 ** to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]
11578 ** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
13032 ** This function is expected to tokenize the nText byte string indicated
13048 ** a bareword or quoted string specified as part of the query.
13051 ** FTS5_TOKENIZE_QUERY, except that the bareword or quoted string is
13061 ** For each token in the input string, the supplied callback xToken() must
14178 #include <string.h>
15892 char *z; /* Pointer to data for string (char array) types */
15952 #define P4_TRANSIENT 0 /* P4 is a pointer to a transient string */
15953 #define P4_STATIC (-1) /* Pointer to a static string */
17569 ** a single allocation. Each string is 0x00 terminated. The datatype
17654 ** when multiple affinity types are concatenated into a string and
18169 ** that the owner of the "z" string does not deallocate the string before
18172 ** static string.
19408 ** An objected used to accumulate the text of a string where we
19409 ** do not necessarily know how big the string will be in the end.
19413 char *zText; /* The string collected so far */
19416 u32 nChar; /* Length of the string so far */
19478 int mxStrlen; /* Maximum string length */
22613 ** structures. Each Mem struct may cache multiple representations (string,
22625 int n; /* Number of characters in string value, excluding '\0' */
22662 ** * MEM_Str A string, stored in Mem.z with
22686 ** If the MEM_Str flag is set then Mem.z points at a string representation.
22689 ** set, then the string is nul terminated. The MEM_Int and MEM_Real
22694 #define MEM_Str 0x0002 /* Value is a string */
22711 /* Bits that determine the storage for Mem.z for a string or blob or
22715 #define MEM_Static 0x2000 /* Mem.z points to a static string */
22716 #define MEM_Ephem 0x4000 /* Mem.z points to an ephemeral string */
22810 ** string for a prepared statement. A linked list of these objects
22814 ** identifier should really be a string literal.
22818 DblquoteStr *pNextStr; /* Next string literal in the list */
22819 char z[8]; /* Dequoted value for the string */
22884 DblquoteStr *pDblStr; /* List of double-quoted string literals */
23801 ** on success and 1 if the input string is not a well-formed
23867 ** Attempt to parse the given string into a julian day number. Return
23870 ** The following are acceptable forms for the input string:
23879 ** as there is a time string. The time string can be omitted as long
24630 ** Return a string described by FORMAT. Conversions as follows:
24800 ** and strftime(). The format string to pass to strftime() is supplied
26210 ** Set the title string for subsequent allocations.
29798 ** Make a copy of a string in memory obtained from sqliteMalloc(). These
29994 etByte charset; /* Offset into aDigits[] of the digits string */
29995 etByte prefix; /* Offset into aPrefix[] of the prefix string */
30150 ** Render a string given by "fmt" into the StrAccum object.
30154 const char *fmt, /* Format string */
30157 int c; /* Next character in the format string */
30847 ** at this point. If the "!" flag was present on string conversions
30864 }/* End for loop over the format string */
30869 ** The z string points to the first character of a token that is
30960 ** Append N copies of character c to the given string buffer.
31005 ** Append the complete text of zero-terminated string z[] to the p string.
31013 ** Finish off a string by making sure it is zero-terminated.
31014 ** Return a pointer to the resulting string. Return a NULL
31066 /* Finalize a string created using sqlite3_str_new().
31097 ** Reset an StrAccum string. Reclaim all malloced memory.
31110 ** Initialize a string accumulator.
31133 /* Allocate and initialize a new dynamic string object */
33208 const unsigned char **pz /* Pointer to string from which to read char */
33213 ** For this routine, we assume the UTF8 string is always zero-terminated.
33240 ** desiredEnc. It is an error if the string is already of the desired
33241 ** encoding, or if *pMem does not contain a string value.
33244 sqlite3_int64 len; /* Maximum length of output string in bytes */
33295 ** A single byte is required for the output string
33431 ** UTF-16 string stored in *pMem. If one is present, it is removed and
33470 ** pZ is a UTF-8 encoded unicode string. If nByte is less than zero,
33500 ** This has the effect of making sure that the string is well-formed
33524 ** Convert a UTF-16 string in the native encoding into a UTF-8 string.
33525 ** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must
33547 ** zIn is a UTF-16 encoded unicode string at least nChar characters long.
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.
33687 ** The column type is an extra string stored after the zero-terminator on
33750 ** Set the most recent error code and error string for the sqlite
33753 ** If it is not NULL, string zFormat specifies the format of the
33754 ** error string. zFormat and any string tokens that follow it are
33827 ** Convert an SQL-style quoted string into a normal string by removing
33832 ** The input string must be zero-terminated. A new zero-terminator
33833 ** is added to the dequoted string.
33836 ** dequoted string, exclusive of the zero terminator, if dequoting does
33895 ** Generate a Token object from a string
33956 ** Compute an 8-bit hash on a string that is insensitive to case differences
34008 ** The string z[] is an text representation of a real number.
34009 ** Convert this string to a double and write it into *pResult.
34011 ** The string z[] is length bytes in length (bytes, not characters) and
34012 ** uses the encoding enc. The string is not necessarily zero-terminated.
34015 ** if the string is empty or contains extraneous text. More specifically
34017 ** 1 => The input string is a pure integer
34019 ** 0 or less => The input string is not a valid number
34032 ** If some prefix of the input string is a valid number, this routine
34258 ** Compare the 19-character string zNum against the text representation
34260 ** if zNum is less than, equal to, or greater than the string.
34300 ** length is the number of bytes in the string (bytes, not characters).
34301 ** The string is not necessarily zero-terminated. The encoding is
34493 ** Return a 32-bit integer value extracted from a string. If the
34494 ** string is not an integer, just return 0.
34811 ** of a 1048569-byte BLOB or string.
37574 ** binaries. This returns the string representation of the supplied
37726 int nName; /* Length of the zCanonicalName[] string */
37787 int n; /* Length of zAbsoluteName string */
38066 ** available, the error message will often be an empty string. Not a
43422 ** is stored as a nul-terminated string in the buffer pointed to by
44595 ** is a string buffer at least MAXPATHLEN+1 characters in size.
45808 ** an ANSI string regardless of the _UNICODE setting */
46405 ** This function outputs the specified (ANSI) string to the Win32 debugger
46745 ** Convert a UTF-8 string to Microsoft Unicode.
46747 ** Space to hold the returned string is obtained from sqlite3_malloc().
46771 ** Convert a Microsoft Unicode string to UTF-8.
46773 ** Space to hold the returned string is obtained from sqlite3_malloc().
46797 ** Convert an ANSI string to Microsoft Unicode, using the ANSI or OEM
46800 ** Space to hold the returned string is obtained from sqlite3_malloc().
46826 ** Convert a Microsoft Unicode string to a multi-byte character string,
46829 ** Space to hold the returned string is obtained from sqlite3_malloc().
46854 ** Convert a multi-byte character string to UTF-8.
46856 ** Space to hold the returned string is obtained from sqlite3_malloc().
46872 ** Convert a UTF-8 string to a multi-byte character string.
46874 ** Space to hold the returned string is obtained from sqlite3_malloc().
46987 ** it accepts a UTF-8 string.
47031 ** it accepts a UTF-16 string.
49780 ** This function returns non-zero if the specified UTF-8 string buffer
49927 ** be used. However, we may need to convert the string containing
51948 ** utf-8 string describing the most recent error encountered associated
56233 ** Journal files begin with the following magic string. The data
56487 ** Return a pointer to a human readable string in a static buffer
56619 ** Write a 32-bit integer into a string buffer in big-endian byte order.
57090 ** the magic string found at the start of each journal header, return
57193 int nSuper; /* Length of string zSuper */
57196 u32 cksum = 0; /* Checksum of string zSuper */
62578 ** Except, if the pager is in-memory only, then return an empty string if
67624 ** 0 16 Header string: "SQLite format 3\000"
67803 ** This is a magic string that appears at the beginning of every
67809 ** the string itself should be 15 characters long. If you change
68613 ** The header string that appears at the beginning of every
78791 ** Append a message to the error message string.
79456 ** an empty string if the database is in-memory or a TEMP database.
80630 /* If p holds a string or blob, the Mem.z must point to exactly
80635 ** (3) An ephemeral string or blob
80636 ** (4) A static string or blob
80680 ** Validity checks on pMem. pMem holds a string.
80682 ** (1) Check that string value of pMem agrees with its integer or real value.
80683 ** (2) Check that the string is correctly zero terminated
80688 ** corresponding string value, then it is important that the string be
80695 ** representation and a string representation then the string rep has
80707 /* Insure that the string is properly zero-terminated. Pay particular
80735 ** If pMem is an object with a valid string representation, this routine
80736 ** ensures the internal encoding for the string representation is
80739 ** If pMem is not a string object, or the encoding of the string
80782 ** pMem->z into the new allocation. pMem must be either a string or
80792 ** contain a valid string or blob value. */
80841 ** Any prior string or blob content in the pMem object may be discarded.
80862 ** It is already known that pMem contains an unterminated string.
80867 ** terminate a UTF16 string, even if the initial size of the buffer
81157 ** If pMem is a string or blob, then we make an attempt to convert
81161 ** If pMem represents a string value, its encoding might be changed.
81189 ** value. If it is a string or blob, try to convert it to a double.
81315 ** is a string that does not look completely like a number. Convert
81316 ** as much of the string as we can and ignore the rest.
81664 ** Change the value of a Mem to be a string or a BLOB.
81668 ** string is copied into a (possibly existing) buffer managed by the
81672 ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
81673 ** size limit) then no memory allocation occurs. If the string can be
81675 ** is required to store the string, then value of pMem is unchanged. In
81678 ** The "enc" parameter is the text encoding for the string, or zero
81681 ** If n is negative, then the string consists of all bytes up to but
81686 Mem *pMem, /* Memory cell to set to string value */
81688 i64 n, /* Bytes in string, or negative */
81693 int iLimit; /* Maximum allowed string or blob size */
81847 ** Convert it into a string with encoding enc and return a pointer
81848 ** to a zero-terminated version of that string.
82251 ** token (i.e. "5", "5.1", "'a string'"). If the expression can
82484 ** Change the string value of an sqlite3_value object
82488 int n, /* Length of string z */
82489 const void *z, /* Text of the new string */
82491 void (*xDel)(void*) /* Destructor for the string */
82591 ** Change the error string stored in Vdbe.zErrMsg
82602 ** Remember the SQL string for a prepared statement.
82635 ** that identifier is really used as a string literal.
82830 /* Generate code to cause the string zStr to be loaded into
82838 ** Generate code that initializes multiple registers to string or integer
82841 ** "s" character in zTypes[], the register is a string if the argument is
82845 ** If the input string does not end with "X" then an OP_ResultRow instruction
83015 ** The zWhere string must have been obtained from sqlite3_malloc().
83915 ** the string is made into memory obtained from sqlite3_malloc().
83920 ** to a string or structure that is guaranteed to exist for the lifetime of
84106 ** Compute a string for the "comment" field of a VDBE opcode listing.
84109 ** to an extra string that is appended to the sqlite3OpcodeName(). In the
84280 ** Compute a string that describes the P4 parameter for an opcode.
85259 ** zName must be a pointer to a nul terminated string.
85370 ** string, it means the main database is :memory: or a temp file. In
86551 ** EVIDENCE-OF: R-28401-00140 Value is a string in the text encoding and
86788 ** Both *pMem1 and *pMem2 contain string values. Compare the two values
86968 /* If one value is a string and the other is a blob, the string is less.
87164 /* RHS is a string */
87381 ** that (a) the first field of pPKey2 is a string, that (b) the first field
87579 ** the key string in pUnpacked. Write into *pRes a number
87958 ** This routine sets the error code and string returned by
87987 ** This routine sets the error code and string returned by
88097 ** point number string BLOB NULL
88235 ** result as a string or blob. Appropriate errors are set if the string/blob
88244 int n, /* Bytes in string, or negative */
88447 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
89182 ** Convert the N-th element of pStmt->pColName[] into a string using
89183 ** xFunc() then return that string. If N is out of range, return 0.
89766 ** bound parameters expanded. Space to hold the returned string is
89768 ** freeing the returned string by passing it to sqlite3_free().
90099 ** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of
90124 ** This function returns a pointer to a nul-terminated string in memory
90126 ** string contains a copy of zRawSql but with host parameters expanded to
90128 ** then the returned string holds a copy of zRawSql with "-- " prepended
90139 ** ALGORITHM: Scan the input string looking for host parameters in any of
90141 ** string literals, quoted identifier names, and comments. For text forms,
90211 int nOut; /* Number of bytes of the string text to include in output */
90297 ** not misused. A shallow copy of a string or blob just copies a
90298 ** pointer to the string or blob, not the content. If the original
90299 ** is changed while the copy is still in use, the string or blob might
90489 ** An ephemeral string value (signified by the MEM_Ephem flag) contains
90490 ** a pointer to a dynamically allocated string where some other entity
90491 ** is responsible for deallocating that string. Because the register
90492 ** does not control the string, it might be deleted without the register
90495 ** This routine converts an ephemeral string into a dynamically allocated
90496 ** string that the register itself controls. In other words, it
90497 ** converts an MEM_Ephem string into a string with P.z==P.zMalloc.
90581 ** The string in pRec is known to look like an integer and to have a
90583 ** integer value if the string is in range to be an integer. Otherwise,
90598 ** do so without loss of information. In other words, if the string
90607 ** If bTryForInt is false, then if the input string contains a decimal
90626 ** string representation after computing a numeric equivalent, because the
90627 ** string representation might not be the canonical representation for the
90668 ** representation (blob and NULL do not get converted) but no string
90670 ** there is already a string rep, but it is pointless to waste those
90713 ** pMem currently only holds a string type (or maybe a BLOB that we can
90714 ** interpret as a string if we want to). Compute its corresponding
90766 ** Write a nice string representation of the contents of cell pMem
91215 ** each string is the symbolic name for the corresponding opcode. If the
91455 ** If P4 is not null then it is an error message string.
91457 ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
91581 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
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.
91626 ** of a string, as if it had been CAST. In other words:
91710 ** instruction, but do not free any string or blob memory associated with
91711 ** the register, so that if the value was a string or blob that was
91825 ** is made of any string or blob constant. See also OP_SCopy.
91858 ** is a string or blob, then the copy is only a pointer to the
92004 i64 nByte; /* Total size of the output string or blob */
92408 ** memcmp() is used to compare text string. If both values are
92452 ** memcmp() is used to compare text string. If both values are
93394 /* If the column value is a string, we need a persistent value, not
93567 ** P4 is a string that is P2 characters long. The N-th character of the
93568 ** string indicates the column affinity that should be used for the N-th
93616 ** P4 may be a string that is P2 characters long. The N-th character of the
93617 ** string indicates the column affinity that should be used for the N-th
93647 char *zAffinity; /* The affinity string for the record */
95012 /* The input value in P3 might be of any type: integer, real, string,
97143 ** Run the SQL statement or statements specified in the P4 string.
98049 ** Write a string containing the final journal-mode to register P2.
98151 ** If P2 is not zero, then it is a register holding a string which is
98313 /* Because P2 is always a static string, it is impossible for the
98424 ** P4 is either NULL or a string that was generated by the xBestIndex
98425 ** method of the module. The interpretation of the P4 string is left
98936 ** the UTF-8 string contained in P4 is emitted on the trace callback.
98937 ** Or if P4 is blank, use the string returned by sqlite3_sql().
98954 /* If the P4 argument is not NULL, then it must be an SQL comment string.
98955 ** The "--" string is broken up to prevent false-positives with srcck1.c.
99230 /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
99234 sqlite3VdbeError(p, "string or blob too big");
103432 /* #include <string.h> */
103815 ** Return TRUE if the double-quoted string mis-feature should be supported.
104296 ** Z is a string literal if it doesn't match any column names. In that
104309 ** then treat it as a string.
104323 "double-quoted string literal: \"%w\"", zCol);
106645 ** Special case: If op==TK_INTEGER and pToken points to a string that
107185 ** of the Expr structure and a copy of the Expr.u.zToken string (if that
107186 ** string is defined.)
107253 ** by the copy of the p->u.zToken string (if any).
107283 /* Copy the p->u.zToken string, if any. */
107893 ** Check the input string to see if it is "true" or "false" (in any case).
107895 ** If the string is.... Return
108081 ** For the purposes of this function, a double-quoted string (ex: "abc")
108082 ** is considered a variable but a single-quoted string (ex: 'abc') is
108228 ** For the purposes of this function, a double-quoted string (ex: "abc")
108229 ** is considered a variable but a single-quoted string (ex: 'abc') is
108378 ** Return TRUE if the given string is a row-id column name.
108773 ** function allocates and returns a nul-terminated string containing
108777 ** string is eventually freed using sqlite3DbFree().
109240 char *zAff = 0; /* Affinity string for comparisons */
109482 ** The z[] string will probably not be zero-terminated. But the
109835 /* The AFFINITY() function evaluates to a string that describes
111334 ** If pExpr is a simple SQL value - an integer, real, string, blob
113402 ** pEList->a[i].zName) that matches the string in zOld, extract the
113428 ** that matches the string in zOld, extract the corresponding rename-token
113483 ** a part of the input string. */
113549 ** All that remains is to construct and return the edited SQL string. */
113573 ** token. This is so that (SELECT "string"'alias') maps to
113574 ** (SELECT 'string' 'alias'), and not (SELECT 'string''alias'). */
114173 ** Rewrite the DDL statement "SQL" so that any string literals that use
114187 ** 'CREATE VIEW v1 AS SELECT "a", "string" FROM t1'
114190 ** returns the string:
114192 ** CREATE VIEW v1 AS SELECT "a", 'string' FROM t1
114195 ** if PRAGMA writable_schema=ON, then just return the input string
114383 ** The value returned is a string containing the CREATE TABLE statement
114652 ** a string consisting of a list of integers. The first integer in this
115442 ** The value is a string composed of a list of integers describing
116065 ** The first argument points to a nul-terminated string containing a
117406 ** parameters can be either NULL or a string. */
117772 /* This can result either from an OOM or because the formatted string
118373 ** Given a token, return a string that consists of the text of that
118374 ** token. Space to hold the returned string
118382 ** are not \000 terminated and are not persistent. The returned string
118505 ** This routine is used to check if the UTF-8 string zName is a legal
118507 ** trigger). All names are legal except those that begin with the string
119544 ** nul-terminated string pointed to by the third parameter, zSignedIdent,
119548 ** If the string zSignedIdent consists entirely of alpha-numeric
120473 ** allocated rather than point to the input string - which means that
123259 ** the collation sequence name. A pointer to this string is stored in
123300 ** Parameter zName points to a UTF-8 encoded string nName bytes long.
123392 ** encoding identified by the string zName.
124901 ** IMP: R-01992-00519 Abs(X) returns 0.0 if X is a string or blob
125160 ** If nByte is larger than the maximum string or blob length, then
125371 ** Compare two UTF-8 strings for equality where the first string is
125410 const u8 *zString, /* The string to compare against the glob */
125414 u32 c, c2; /* Next pattern and input string chars */
125424 ** single character of the input string for each "?" skipped */
125451 ** pattern string past the "*". Search in the input string for the
125456 ** c but in the other case and search the input string for either
125578 ** pattern and the second argument is the string. So, the SQL statements:
125622 /* The escape character string must consist of a single UTF-8 character.
125686 ** Implementation of the sqlite_source_id() function. The result is a string
125742 ** The result is a string that identifies the compiler options
125774 /* As currently implemented, the string must be initially empty.
125839 ** embedded NUL characters cannot be represented as string literals in SQL
125840 ** and hence the returned string literal is truncated prior to the first NUL.
125859 ** for the first character of the input string.
125873 ** an integer. It constructs a string where each character of the string
125964 ** them A, B, and C. The result is also a string which is derived
125973 const unsigned char *zStr; /* The input string A */
125974 const unsigned char *zPattern; /* The pattern string B */
125975 const unsigned char *zRep; /* The replacement string C */
126066 const unsigned char *zIn; /* Input string */
126171 ** IMP: R-59782-00072 The soundex(X) function returns a string that is the
126172 ** soundex encoding of the string X.
126216 /* IMP: R-64894-50321 The string "?000" is returned if the argument
126468 ** The SEPARATOR goes before the EXPR string. This is tragic. The
126479 /* If pnSepLengths!=0, refs an array of inter-string separator lengths,
126586 /* If removing single accumulated string, harmlessly over-do. */
126687 ** operator if c is a string literal that is exactly one byte in length.
128656 ** Return a pointer to the column affinity string associated with index
128657 ** pIdx. A column affinity string has one character for each column in
128668 ** An extra 'D' is appended to the end of the string to cover the
128671 ** Memory for the buffer containing the column index affinity string
128677 /* The first time a column affinity string for a particular index is
128681 ** The column affinity string will eventually be deleted by
128716 ** Compute an affinity string for a table. Space is obtained
128744 ** Compute the affinity string for table pTab, if it has not already been
128747 ** If the affinity string is empty (because it was all SQLITE_AFF_BLOB entries
128753 ** an OP_MakeRecord) to the affinity string.
128755 ** A column affinity string has one character per column:
132299 char **pzErrMsg, /* Used to set error string on failure. */
134272 ** Interpret the given string as a safety level. Return 0 for OFF,
134274 ** unrecognized string argument. The FULL and EXTRA option is disallowed
134305 ** Interpret the given string as a boolean value.
134318 ** Interpret the given string as a locking mode value.
134330 ** Interpret the given string as an auto-vacuum mode value.
134347 ** Interpret the given string as a temp db location. Return 1 for file
134592 ** string held in register 3. Decrement the result count in register 1
134611 ** The identifier might also be a string. The value is a string, and
134617 ** id and pId2 is any empty string.
134626 char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
134627 char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
135216 ** Setting to a null string reverts to the default temporary directory search.
135260 ** were specified with a relative pathname. Setting to a null string reverts
137220 const char **pzTail /* OUT: End of parsed string */
137304 db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
137827 const char **pzTail /* OUT: End of parsed string */
137972 const char **pzTail /* OUT: End of parsed string */
138056 const char **pzTail /* OUT: End of parsed string */
138068 const char **pzTail /* OUT: End of parsed string */
138087 const char **pzTail /* OUT: End of parsed string */
138115 const void **pzTail /* OUT: End of parsed string */
138118 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
138146 ** equivalent pointer into the UTF-16 string by counting the unicode
138148 ** the same number of characters into the UTF-16 string.
138172 const void **pzTail /* OUT: End of parsed string */
138184 const void **pzTail /* OUT: End of parsed string */
138197 const void **pzTail /* OUT: End of parsed string */
140078 ** Return a pointer to a string containing the 'declaration type' of the
140079 ** expression pExpr. The string may be treated as static by the caller.
145215 ** The fake column name is an empty string. It is possible for a table to
145216 ** have a column named by the empty string, in which case there is no way to
145221 ** string for the fake column name seems safer.
146811 ** holds both the TriggerStep object and the TriggerStep.target.z string.
147205 ** Convert the pStep->zTarget string into a SrcList and return a pointer
147886 ** literal default values specified: a number, null or a string. (If a more
147892 ** the column is a literal number, string or null. The sqlite3ValueFromExpr()
149540 ** a format string as its third argument
150292 ** The string is not copied - the pointer is stored. The
150293 ** string will be freed automatically when the table is
150581 ** the type string. */
151459 char *idxStr; /* Index identifier string */
152009 ** string similar to:
152065 StrAccum str; /* EQP output string */
152066 char zBuf[100]; /* Initial space for EQP output string */
152174 StrAccum str; /* EQP output string */
152175 char zBuf[100]; /* Initial space for EQP output string */
152303 ** Code an OP_Affinity opcode to apply the column affinity string zAff
152322 ** entries at the beginning and end of the affinity string.
152345 ** affinity string to SQLITE_AFF_BLOB if either:
152353 char *zAff /* Affinity string to modify */
152658 ** compute the affinity string.
152674 ** copy of the column affinity string of the index allocated using
152675 ** sqlite3DbMalloc(). Except, entries in the copy of the string associated
152686 ** string in this example would be set to SQLITE_AFF_BLOB.
152693 char **pzAff /* OUT: Set to point to affinity string */
152704 char *zAff; /* Affinity string to return */
152799 ** (a string literal) that originated from the LIKE optimization, then
152800 ** set P3 and P5 on the OP_String opcode so that the string will be cast
152807 ** bound string constants to blobs. This routine makes the necessary changes
152811 ** only the one pass through the string space is required, so this routine
154862 ** In order for the operator to be optimizible, the RHS must be a string
154864 ** that may only be NULL, a string, or a BLOB, never a number. (This means
158528 ** required for string comparison, or if unable to allocate memory
158592 ** required for string comparison, or if unable to allocate memory
163668 ** names are used, rather than string literals, so that FuncDef objects
164372 ** equivalent nul-terminated string.
165313 ** Since all strings and blobs are greater-than-or-equal-to an empty string,
167707 ** <li> A prefix string written at the beginning of every
171692 ** This file contains C code that splits an SQL input string up into
172358 ** Return the id of the next token in string (*pz). Before returning, set
172729 ** Run the parser on the given SQL string.
172738 int mxSqlLen; /* Max length of an SQL string */
172887 ** Insert a single space character into pStr if the current string
172903 const char *zSql /* The original SQL string */
172914 sqlite3_str *pStr; /* The normalized SQL string under construction */
173072 ** Return TRUE if the given SQL string ends in a semicolon.
173118 ** This means that a SQL string of all whitespace is invalid.
173122 ** is look for a semicolon that is not part of an string or comment.
173506 /* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
173513 ** a pointer to the to the sqlite3_version[] string constant.
173518 ** pointer to a string constant whose value is the same as the
173559 ** If the following global variable points to a string which is the
173568 ** If the following global variable points to a string which is the
174902 ** Return a static string containing the name corresponding to the error code
175014 ** Return a static string that describes the kind of error specified in the
175037 /* SQLITE_TOOBIG */ "string or blob too big",
175910 ** to contains a zero-length string, all attached databases are
176113 ** Return a string that describes the kind of error specified in the
176721 db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
176748 ** Legacy behavior is 3 (double-quoted string literals are allowed anywhere)
178093 ** It is an error to pass this routine a filename string that was not
178352 ** Return the N-th compile-time option string. If N is out of range,
179265 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
179611 Fts3Expr *pExpr; /* Parsed MATCH query string */
179677 ** nToken will be the number of tokens in the string.
179943 /* #include <string.h> */
180092 ** Convert an SQL-style quoted string into a normal string by removing
180208 ** Construct one or more SQL statements from the format string given
180217 const char *zFormat, /* Format string for SQL */
180218 ... /* Arguments to the format string */
180451 ** Append the output of a printf() style formatting to an existing string.
180455 char **pz, /* IN/OUT: Pointer to string buffer */
180456 const char *zFormat, /* Printf format string to append */
180457 ... /* Arguments for printf format string */
180477 ** Return a copy of input string zInput enclosed in double-quotes (") and
180516 ** string is returned:
180573 ** user-defined text columns, the following string is returned:
180624 ** This function interprets the string at (*pp) as a non-negative integer
180728 ** *pazCol: Set to point to an array of *pnCol strings. Each string is
180744 int *pnStr, /* OUT: Bytes of string content */
183323 ** string passed via zFunc is used as part of the error message.
185777 /* #include <string.h> */
185793 int nStop; /* Byte-length of string zStop */
186400 /* #include <string.h> */
186498 const char *z, int n, /* Input string */
186583 ** Buffer zInput, length nInput, contains the contents of a quoted string
186596 const char *zInput, int nInput, /* Input string */
186714 const char *z, int n, /* Input string */
186741 ** close bracket, or a quoted string.
186798 ** search for the closing quote and pass the whole string to getNextString()
186800 ** a quote character embedded in a string.
187329 ** nul-terminated string and the length is determined using strlen().
187340 ** specified as part of the query string), or -1 if tokens may by default
187646 /* #include <string.h> */
188032 /* #include <string.h> */
188085 ** Prepare to begin tokenizing a particular string. The input
188086 ** string to be tokenized is zInput[0..nInput-1]. A cursor
188087 ** used to incrementally tokenize this string is returned in
188139 ** the string they point to is a consonant or a vowel, according
188696 /* #include <string.h> */
188722 ** to the string <key-name>. If <pointer> is not specified, then
188723 ** the string <key-name> must already exist in the has table. Otherwise,
188728 ** to string <key-name> (after the hash-table is updated, if applicable).
188900 /* #include <string.h> */
188907 ** SELECT <function-name>(<key-name>, ..., <input-string>);
188911 ** concatenated with the string '_test' (e.g. 'fts3_tokenizer_test').
188913 ** The return value is a string that may be interpreted as a Tcl
188914 ** list. For each token in the <input-string>, three elements are
188917 ** substring of <input-string> associated with the token. For example,
188922 ** will return the string:
189129 ** been initialized to use string keys, and to take a private copy
189220 /* #include <string.h> */
189297 ** Prepare to begin tokenizing a particular string. The input
189298 ** string to be tokenized is pInput[0..nBytes-1]. A cursor
189299 ** used to incrementally tokenize this string is returned in
189452 ** input = <string>
189454 ** The virtual table module tokenizes this <string>, using the FTS3
189459 ** input: Always set to a copy of <string>
189461 ** start: Byte offset of the token within the input <string>.
189463 ** token within the input string.
189470 /* #include <string.h> */
189490 char *zInput; /* Input string */
189910 /* #include <string.h> */
190669 ** Tokenize the nul-terminated string zText and add all tokens to the
194995 const char *zParam /* Nul-terminated string containing "A,B" */
195038 const char *zParam /* Nul-terminated string containing boolean */
195721 /* #include <string.h> */
195826 char *z; /* Pointer to buffer containing string */
196300 ** Append a string to the string-buffer passed as the first argument.
196302 ** If nAppend is negative, then the length of the string zAppend is
196329 /* Append the data to the string buffer. */
196420 ** append it to string buffer pOut.
196920 ** format string passed as the second argument to matchinfo (or the
196922 ** string has already been validated and the pInfo->aMatchinfo[] array
196938 const char *zArg /* Matchinfo format string */
197073 /* If there is cached matchinfo() data, but the format string for the
197074 ** cache does not match the format string for this request, discard
197302 StrBuffer res = {0, 0, 0}; /* Result string */
197327 ** string-buffer res for each column.
197482 /* #include <string.h> */
197574 ** all characters in string zIn/nIn to be separators (if bAlnum==0) or
197577 ** For each codepoint in the zIn/nIn string, this function checks if the
197585 ** identifies as a diacritic) occurs in the zIn/nIn string it is ignored.
197724 ** Prepare to begin tokenizing a particular string. The input
197725 ** string to be tokenized is pInput[0..nBytes-1]. A cursor
197726 ** used to incrementally tokenize this string is returned in
197731 const char *aInput, /* Input string */
197732 int nInput, /* Size of string aInput in bytes */
198307 /* An instance of this object represents a JSON string
198308 ** under construction. Really, this is a generic string accumulator
198369 /* A completely parsed JSON string
198375 const char *zJson; /* Original JSON string */
198380 int nJson; /* Length of the zJson string in bytes */
198397 /* Set the JsonString object to an empty string
198460 /* Append N bytes from zIn onto the end of the JsonString string.
198497 /* Append the N-byte string in zIn to the end of the JsonString string
198498 ** under construction. Enclose the string in "..." and escape
198500 ** string.
198542 ** Append a function parameter value to the JSON string under
198546 JsonString *p, /* Append to this JSON string */
198634 ** Convert the JsonNode pNode into a pure JSON string and
198725 ** Return a JsonNode and all its descendents as a JSON string.
198755 ** Convert a 4-byte hex string into an integer
198852 /* Translate JSON formatted string into raw text */
199074 /* Parse string */
199164 ** Parse a complete JSON string. Return 0 on success or non-zero if there
199607 ** The json_parse(JSON) function returns a string which describes
199616 JsonString s; /* Output string - not real JSON */
199670 ** double-quotes around strings and returning the unquoted string "null"
199974 ** is not a string or if any value is a BLOB, throw an error.
200153 ** Return the top-level "type" of a JSON string. json_type() raises an
200181 ** Return 1 if JSON is a well-formed JSON string according to RFC-7159.
200256 ** to the first comma (",") that is not within a string and deleting all
200747 /* Start a search on a new JSON string */
201045 /* #include <string.h> */
204683 int nDb; /* Length of string argv[1] */
204684 int nName; /* Length of string argv[2] */
204805 ** The human readable string takes the form of a Tcl list with one
204911 ** The second and subsequent arguments to this function are a format string
204912 ** and printf style arguments. This function formats the string and attempts
204920 const char *zFmt, ... /* Format string and trailing args */
204944 ** style format string and arguments. This function formats the string and
205705 ** If the input is a well-formed Geopoly BLOB or JSON string
206581 sqlite3_int64 nDb; /* Length of string argv[1] */
206582 sqlite3_int64 nName; /* Length of string argv[2] */
207467 ** Compare two UTF-8 strings for equality where the first string is
207473 const uint8_t *zString, /* The UTF-8 string to compare against */
207501 ** test string.
207549 ** pattern and the second argument is the string. So, the SQL statements:
207578 /* The escape character string must consist of a single UTF-8 character.
207610 ** the second is a string to match against that pattern. If either
207612 ** is 1 if the string matches the pattern, or 0 otherwise.
207701 ** of the locale to use. Passing an empty string ("") or SQL NULL value
207711 const UChar *zInput; /* Pointer to input string */
207713 int nInput; /* Size of utf-16 input string in bytes */
207807 ** Where <locale> is a string containing an ICU locale identifier (i.e.
207926 /* #include <string.h> */
207996 ** Prepare to begin tokenizing a particular string. The input
207997 ** string to be tokenized is pInput[0..nBytes-1]. A cursor
207998 ** used to incrementally tokenize this string is returned in
208003 const char *zInput, /* Input string */
208256 /* #include <string.h> */
208456 ** ota_control string, the contents of the data_xxx table column is assumed
209293 ** the integer. The *pLen parameter holds the length of the string
209364 ** The delta string should be null-terminated. But the delta string
209370 ** the final NUL terminator character). Except, if the delta string is
209840 ** Argument zFmt is a sqlite3_mprintf() style format string. The trailing
209912 ** The first argument must be a nul-terminated string. This function
209913 ** returns a copy of the string in memory obtained from sqlite3_malloc().
210241 ** string containing some SQL clause or list based on one or more of the
210481 ** "ipk", the returned string is:
210485 ** As well as the returned string, three other malloc'd strings are
210595 ** paramter is passed "old", return a string of the form:
210641 ** Return the string:
210693 ** Return a nul-terminated string containing the comma separated list of
210699 ** The memory for the returned string is obtained from sqlite3_malloc().
210704 ** string, an error code is left in the rbu handle passed as the first
210749 ** Return a nul-terminated string consisting of nByte comma separated
210751 ** a buffer containing the string "?,?,?".
210753 ** The memory for the returned string is obtained from sqlite3_malloc().
210758 ** string, an error code is left in the rbu handle passed as the first
210861 ** zIdx to point to a nul-terminated string containing this name. */
211391 ** If the zMask string does not specify any columns to update, then this
212379 ** where $zPragma is the string passed as the second argument, then
212997 ** then edit any error message string so as to remove all occurrences of
214009 ** utf-8 string describing the most recent error encountered associated
215520 /* #include <string.h> */
216897 /* This may fail if SQLite value p contains a utf-16 string that must
217470 int nName; /* Number of bytes in string zName */
217617 ** called. Otherwise, append a string to the buffer. All bytes in the string
217637 ** called. Otherwise, append the string representation of integer iVal
217645 int iVal, /* Value to write the string rep. of */
217655 ** called. Otherwise, append the string zStr enclosed in quotes (") and
218476 ** first argument to a copy of the string or blob held in the aData[]
218482 u8 *aData, /* Buffer containing string or blob data */
221693 ** This function is expected to tokenize the nText byte string indicated
221709 ** a bareword or quoted string specified as part of the query.
221712 ** FTS5_TOKENIZE_QUERY, except that the bareword or quoted string is
221722 ** For each token in the input string, the supplied callback xToken() must
221950 /* #include <string.h> */
222090 ** the string "rowid" otherwise. This text is not quoted - if it is
222197 ** Buffer object for the incremental building of string data.
223176 ** <li> A prefix string written at the beginning of every
224408 ** Append text to the HighlightContext output string - p->zOut. Argument
224646 ** contains a NULL value, return a pointer to a static string zero
225074 ** Append the nul-terminated string zStr to the buffer pBuf. This function
225089 ** Argument zFmt is a printf() style format string. This function performs
225272 ** Return a nul-terminated copy of the string indicated by pIn. If nIn
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().
225444 ** string. Return a pointer to the first character following *pIn in
225445 ** the string that is not a white-space character.
225457 ** string. Return a pointer to the first character following *pIn in
225458 ** the string that is not a "bareword" character.
225537 ** The first character of the string pointed to by argument z is guaranteed
225541 ** the string and, if found, dequotes the string in place and adds a new
225582 ** Convert an SQL-style quoted string into a normal string by removing
225826 const char *zIn, /* Buffer to gobble string/bareword from */
225890 ** Populate the Fts5Config.zContentExprlist string.
225914 ** Arguments nArg/azArg contain the string arguments passed to the xCreate
226169 const char *zIn, /* Input string */
226522 ** Read the first token from the nul-terminated string at *pz.
226560 sqlite3Fts5ParseError(pParse, "unterminated string");
228135 ** This function is called by the parser to process a string token. The
228136 ** string may or may not be quoted. In any case it is tokenized and a
229483 ** following type. Each object, its key (a nul-terminated string) and
235497 ** pIn is a UTF-8 encoded string, nIn bytes in size. Return the number of
235498 ** unicode characters in the string.
236446 ** each varint and append its string representation to buffer pBuf. Return
243187 ** of a 1048569-byte BLOB or string.
243563 ** Translate a string containing an fts5vocab table type to an
244291 /* #include <string.h> */