Lines Matching full:sql
131 ** The maximum length of a single SQL statement in bytes.
159 ** if the number of terms is too large. In practice, most SQL
176 ** The maximum number of arguments to an SQL function.
711 ** See also: SQL functions [sqlite_compileoption_used()] and
847 ** that allows an application to run multiple statements of SQL
851 ** semicolon-separate SQL statements passed into its 2nd argument,
855 ** coming out of the evaluated SQL statements. ^The 4th argument to
861 ** ^If an error occurs while evaluating the SQL statements passed into
875 ** without running any subsequent SQL statements.
889 ** SQL comments, then no SQL statements are evaluated and the database
899 ** <li> The application must not modify the SQL statement text passed into
905 const char *sql, /* SQL to be evaluated */
925 #define SQLITE_ERROR 1 /* SQL error or missing database */
2040 ** This function is accessible to SQL statements via the
2041 ** [last_insert_rowid() SQL function].
2056 ** or inserted or deleted by the most recently completed SQL statement
2075 ** Most SQL statements are
2098 ** [count_changes pragma], and the [changes() SQL function].
2124 ** [count_changes pragma], and the [total_changes() SQL function].
2146 ** ^If an SQL operation is very nearly finished at the time when
2150 ** ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
2151 ** ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
2156 ** SQL statements on [database connection] D complete. ^Any new SQL statements
2159 ** running prior to the sqlite3_interrupt() call. ^New SQL statements
2163 ** SQL statements is a no-op and has no effect on SQL statements
2172 ** CAPI3REF: Determine If An SQL Statement Is Complete
2175 ** currently entered text seems to form a complete SQL statement or
2178 ** appears to be a complete SQL statement. ^A statement is judged to be
2189 ** ^These routines do not parse the SQL statements thus
2190 ** will not detect syntactically incorrect SQL.
2196 ** regardless of whether or not the input SQL is complete.)^
2204 SQLITE_API int sqlite3_complete(const char *sql);
2205 SQLITE_API int sqlite3_complete16(const void *sql);
2346 ** semicolon-separated SQL statements in the zero-terminated UTF-8
2367 const char *zSql, /* SQL to be evaluated */
2408 ** options that are useful for constructing SQL statements.
2424 ** One can use this text in an SQL statement as follows:
2433 ** is escaped and the SQL generated is as follows:
2439 ** This is correct. Had we used %s instead of %q, the generated SQL
2446 ** This second example is an SQL syntax error. As a general rule you should
2460 ** The code above will render a correct SQL statement in the zSQL
2577 ** the build-in random() and randomblob() SQL functions. This interface allows
2596 ** ^The authorizer callback is invoked as SQL statements are being compiled
2603 ** specific action but allow the SQL statement to continue to be
2604 ** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
2635 ** SQL statements from an untrusted source, to ensure that the SQL statements
2639 ** SQL queries for evaluation by a database. But the application does
2642 ** user-entered SQL is being [sqlite3_prepare | prepared] that
2645 ** Applications that need to process SQL from untrusted sources
2686 #define SQLITE_DENY 1 /* Abort the SQL statement with an error */
2693 ** that is invoked to authorize certain SQL statement actions. The
2706 ** top-level SQL code.
2747 ** tracing and profiling the execution of SQL statements.
2750 ** various times when an SQL statement is being run by [sqlite3_step()].
2752 ** SQL statement text as the statement first begins executing.
2755 ** contain a UTF-8 SQL comment that identifies the trigger.)^
2758 ** as each SQL statement finishes. ^The profile callback contains
2947 ** CAPI3REF: SQL Statement Object
2950 ** An instance of this object represents a single SQL statement.
2952 ** "compiled SQL statement" or simply as a "statement".
2961 ** <li> Run the SQL by calling [sqlite3_step()] one or more times.
3005 ** interface to further control untrusted SQL. The size of the database
3027 ** <dd>The maximum length of an SQL statement, in bytes.</dd>)^
3042 ** used to implement an SQL statement. This limit is not currently
3057 ** <dd>The maximum index number of any [parameter] in an SQL statement.)^
3076 ** CAPI3REF: Compiling An SQL Statement
3077 ** KEYWORDS: {SQL statement compiler}
3079 ** To execute an SQL query, it must first be compiled into a byte-code
3102 ** past the end of the first SQL statement in zSql. These routines only
3108 ** to NULL. ^If the input text contains no SQL (if the input is an empty
3111 ** SQL statement using [sqlite3_finalize()] after it has finished with it.
3122 ** original SQL text. This causes the [sqlite3_step()] interface to
3128 ** always used to do, [sqlite3_step()] will automatically recompile the SQL
3157 const char *zSql, /* SQL statement, UTF-8 encoded */
3164 const char *zSql, /* SQL statement, UTF-8 encoded */
3171 const void *zSql, /* SQL statement, UTF-16 encoded */
3178 const void *zSql, /* SQL statement, UTF-16 encoded */
3185 ** CAPI3REF: Retrieving Statement SQL
3188 ** SQL text used to create a [prepared statement] if that statement was
3194 ** CAPI3REF: Determine If An SQL Statement Writes The Database
3236 ** implementation of [application-defined SQL functions] are protected.
3247 ** CAPI3REF: SQL Function Context Object
3249 ** The context in which an SQL function executes is stored in an
3251 ** is always first parameter to [application-defined SQL functions].
3252 ** The application-defined SQL function implementation will pass this
3263 ** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
3265 ** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
3279 ** parameters (also called "host parameter names" or "SQL parameters")
3286 ** ^The second argument is the index of the SQL parameter to be set.
3287 ** ^The leftmost SQL parameter has an index of 1. ^When the same named
3288 ** SQL parameter is used more than once, second and subsequent
3353 ** CAPI3REF: Number Of SQL Parameters
3355 ** ^This routine can be used to find the number of [SQL parameters]
3356 ** in a [prepared statement]. SQL parameters are tokens of the
3376 ** the name of the N-th [SQL parameter] in the [prepared statement] P.
3377 ** ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
3402 ** ^Return the index of an SQL parameter given its name. ^The
3428 ** [prepared statement]. ^This routine returns 0 if pStmt is an SQL
3545 ** CAPI3REF: Evaluate An SQL Statement
3576 ** ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
3611 ** with the "v2" interface. If you prepare all of your SQL statements
3680 ** If the SQL statement does not currently point to a valid row, or if the
3870 ** ^Any SQL statement variables that had values bound to them using
3892 ** CAPI3REF: Create Or Redefine SQL Functions
3894 ** KEYWORDS: {application-defined SQL function}
3895 ** KEYWORDS: {application-defined SQL functions}
3898 ** are used to add SQL functions or aggregates or to redefine the behavior
3899 ** of existing SQL functions or aggregates. The only differences between
3905 ** ^The first parameter is the [database connection] to which the SQL
3907 ** connection then application-defined SQL functions must be added
3910 ** ^The second parameter is the name of the SQL function to be created or
3918 ** is the number of arguments that the SQL function or
3919 ** aggregate takes. ^If this parameter is -1, then the SQL function or
3926 ** [SQLITE_UTF8 | text encoding] this SQL function prefers for
3927 ** its parameters. Every SQL function implementation must be able to work
3941 ** pointers to C-language functions that implement the SQL function or
3942 ** aggregate. ^A scalar SQL function requires an implementation of the xFunc
3944 ** parameters. ^An aggregate SQL function requires an implementation of xStep
3946 ** SQL function or aggregate, pass NULL poiners for all three function
3963 ** SQL function is used. ^A function implementation with a non-negative
4044 ** CAPI3REF: Obtaining SQL Function Parameter Values
4046 ** The C-language implementation of SQL functions and aggregates uses
4052 ** define callbacks that implement the SQL functions and aggregates.
4055 ** each parameter to the SQL function. These routines are used to
4086 ** the SQL function that supplied the [sqlite3_value*] parameters.
4104 ** Implementations of aggregate SQL functions use this
4133 ** [sqlite3_context | SQL function context] that is the first parameter
4138 ** the aggregate SQL function is running.
4170 ** The following two functions may be used by scalar SQL functions to
4172 ** multiple invocations of the same SQL function during query execution, under
4176 ** metadata associated with the SQL value passed as the regular expression
4196 ** or when the SQL statement completes, whichever comes first.
4207 ** the SQL function is running.
4232 ** CAPI3REF: Setting The Result Of An SQL Function
4235 ** implement SQL functions and aggregates. See
4241 ** Refer to the [SQL parameter] documentation for additional information.
4257 ** cause the implemented SQL function to throw an exception.
4939 ** See also the [load_extension() SQL function].
4953 ** extension loading while evaluating user-entered SQL, the following API
5348 ** interface. Use the [UPDATE] SQL command to change the size of a
5352 ** and the built-in [zeroblob] SQL function can be used, if desired,
5802 ** databases that are added using the [ATTACH] SQL command.
6634 ** virtual tables, collating functions, and SQL functions. While there is
6706 ** from SQL.
6725 ** from SQL. ^The [sqlite3_wal_autocheckpoint()] interface and the
6788 double *aParam; /* Parameters passed to SQL geom function */
7341 ** implementation of an SQL aggregate step callback may not use the
7521 ** is stored in the leaves. (BTREE_INTKEY is used for SQL tables.) With
7523 ** anywhere - the key is the content. (BTREE_BLOBKEY is used for SQL
8860 ** SQL statements.
9048 #define SQLITE_SqlTrace 0x00004000 /* Debug print SQL as it executes */
9092 ** Each SQL function is defined by an instance of the following
9106 char *zName; /* SQL name of the function. */
9213 ** information about each column of an SQL table is held in an instance
9326 ** connection as that used to execute SQL operations on the virtual table.
9361 ** Each SQL table is represented in memory by an instance of the
9395 Index *pIndex; /* List of SQL indexes on this table. */
9567 ** Each SQL index is represented in memory by an
9597 Table *pTable; /* The SQL table being indexed */
9705 ** If the expression is an SQL literal (TK_INTEGER, TK_FLOAT, TK_BLOB,
9706 ** or TK_STRING), then Expr.token contains the text of the SQL literal. If
9708 ** variable name. Finally, if the expression is an SQL function (TK_FUNCTION),
9714 ** Expr.x.pList is a list of arguments if the expression is an SQL function,
9730 ** character '?' in the original SQL) then the Expr.iTable holds the index
9942 ** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL,
9961 Table *pTab; /* An SQL table corresponding to zName */
10265 ** An SQL parser context. A copy of this structure is passed through
10340 int nVar; /* Number of '?' variables seen in the SQL so far */
10351 const char *zTail; /* All SQL text past the last semicolon parsed */
10391 #define OPFLAG_ISUPDATE 0x04 /* This OP_Insert is an sql UPDATE */
10409 * containing the SQL statements specified as the trigger program.
10436 * An instance of struct TriggerStep is used to store a single SQL statement
11985 ** SQL is translated into a sequence of instructions to be
12101 ** Internally, the vdbe manipulates nearly all SQL values as Mem
12137 ** If the MEM_Null flag is set, then the value is an SQL NULL value.
12211 ** implement the SQL functions.
12284 u8 explain; /* True if EXPLAIN present on SQL command */
12298 char *zSql; /* Text of the SQL statement that generated this */
13667 ** This function registered all of the above C functions as SQL
18297 NULL pointers replaced by SQL NULL. %Q */
20096 ** compiling an SQL statement (i.e. within sqlite3_prepare()). The
20120 ** Convert an SQL-style quoted string into a normal string by removing
28198 ** SQL pragmas
48688 ** Statement subtransactions are used around individual SQL statements
48711 ** SQL statements. It is illegal to open, release or rollback any
52258 ** BTREE_INTKEY|BTREE_LEAFDATA Used for SQL tables with rowid keys
52259 ** BTREE_ZERODATA Used for SQL indices
54512 ** an SQL-NULL value, return 0.
54815 ** pFrom contains an SQL NULL when this routine returns.
54858 /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
55359 ** Remember the SQL string for a prepared statement.
55373 ** Return the SQL associated with a prepared statement
56551 ** Print the SQL that was used to generate a VDBE program.
56561 printf("SQL: [%s]\n", z);
56568 ** Print an IOTRACE message showing SQL content.
56591 sqlite3IoTrace("SQL %s\n", z);
56646 ** The first call is made while compiling the SQL statement. Subsequent
56655 int nVar, /* Number of '?' see in the SQL statement */
56686 /* Allocate space for memory registers, SQL variables, VDBE cursors and
56687 ** an array to marshal SQL function arguments in. This is only done the
56879 ** Set the number of result columns that will be returned by this SQL
56882 ** be called on an SQL statement before sqlite3_step().
56903 ** Set the name of the idx'th column to be returned by the SQL statement.
58432 ** parameter iVar of VM v. Except, if the value is an SQL NULL, return
58456 ** Configure SQL variable iVar so that binding a new value to it signals
58558 ** Terminate the current execution of an SQL statement and reset it
58582 ** Set all the parameters in the compiled SQL statement to NULL.
58933 /* This case occurs after failing to recompile an sql statement.
58934 ** The error message from the SQL compiler has already been loaded
58981 ** The following is the implementation of an SQL function that always
58984 ** SQL function that use this routine so that the functions will exist
59143 ** value SQL NULL. Even though the Mem structure contains an element
59169 ** column value (i.e. a value returned by evaluating an SQL expression in the
59319 ** Return the name of the Nth column of the result set returned by SQL
59345 ** of the result set of SQL statement pStmt.
59412 ** Routines used to attach values to wildcards in a compiled SQL statement.
59501 ** Bind a blob value to an SQL statement variable.
59788 ** (aka "wildcards") into the SQL text output by sqlite3_trace().
59794 ** zSql is a zero-terminated string of UTF-8 SQL text. Return the number of
59836 const char *zRawSql /* Raw text of the SQL statement */
59938 ** The SQL parser generates a program which is then executed by
59939 ** the VDBE to do the work of the SQL statement. VDBE programs are
59949 ** number, or the SQL "NULL" value. An implicit conversion from one
62989 "SQL statements in progress");
63038 "cannot %s savepoint - SQL statements in progress",
63135 "SQL statements in progress");
63142 "SQL statements in progress");
63525 ** to a TEMP table at the SQL level, or to a table opened by
63629 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
63631 ** to an SQL index, then P3 is the first in an array of P4 registers
63642 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
63644 ** to an SQL index, then P3 is the first in an array of P4 registers
63655 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
63657 ** to an SQL index, then P3 is the first in an array of P4 registers
63668 ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
63670 ** to an SQL index, then P3 is the first in an array of P4 registers
64760 ** Register P2 holds a SQL index key made using the
65011 ** intkey table (an SQL table, not an index). In this case the row change
65124 ** schema of database u.bu.iDb before the SQL statement runs. The schema
65137 "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid",
65415 ** It is recursive invocation of triggers, at the SQL level, that is
65909 ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
66367 sqlite3DebugPrintf("SQL-trace: %s\n", u.cm.zTrace);
66550 /* Set the value of the SQL statements only variable to integer iRow.
66784 ** always return an SQL NULL. This is useful because it means
67474 ** an SQL statement.
68251 ** same integer value that would be used in the SQL statement to indicate
69330 ** in the original SQL statement.
69337 ** the SQL statement comes from an external source.
69408 sqlite3ErrorMsg(pParse, "too many SQL variables");
70208 ** needs to know whether or not the structure contains an SQL NULL
72580 ** This function is used by SQL generated to implement the
72642 ** This C function implements an SQL user function that is used by SQL code
72705 /* This function is used by SQL generated to implement the
73052 "sql = sqlite_rename_parent(sql, %Q, %Q) "
73063 "sql = sqlite_rename_table(sql, %Q), "
73065 "sql = CASE "
73066 "WHEN type = 'trigger' THEN sqlite_rename_trigger(sql, %Q)"
73067 "ELSE sqlite_rename_table(sql, %Q) END, "
73103 "sql = sqlite_rename_trigger(sql, %Q), "
73199 ** for an SQL NULL default below.
73255 "sql = substr(sql,1,%d) || ', ' || %Q || substr(sql,%d) "
73586 ** initialized to contain an SQL NULL.
74077 ** is slightly different from resolving a normal SQL expression, because simple
74111 ** An SQL user-function registered to do the work of an ATTACH statement. The
74118 ** If the optional "KEY z" syntax is omitted, an SQL NULL is passed as the
74285 ** An SQL user-function registered to do the work of an DETACH statement. The
74342 ** sqlite_detach() or sqlite_attach() SQL user functions.
74485 ** was left unspecified in the original SQL statement. The pFix structure
74661 ** means that the SQL statement will never-run - the sqlite3_exec() call
74662 ** will return with an error. SQLITE_IGNORE means that the SQL statement
74697 ** to an SQL NULL expression. Otherwise, if pExpr is NULL, then SQLITE_IGNORE
74865 ** following kinds of SQL syntax:
74878 ** This routine is called when a new SQL statement is beginning to
74967 ** This routine is called after a single SQL statement has been
75068 ** code for the SQL statement given onto the end of the pParse context
75400 ** Tokens are often just pointers into the original SQL text and so
76157 ** characters, does not begin with a digit and is not an SQL keyword,
76315 /* If the db->init.busy is 1 it means we are reading the SQL off the
76410 "SET type='%s', name=%Q, tbl_name=%Q, rootpage=#%d, sql=%Q "
76724 ** The "#NNN" in the SQL is a special constant that means whatever value
77185 ** Create a new index for an SQL table. pName1.pName2 is the name of the index
78212 ** release or rollback an SQL savepoint.
79647 ** This file contains the C functions that implement various SQL
79952 ** Implementation of the upper() and lower() SQL functions.
80074 ** Implementation of the last_insert_rowid() SQL function. The return
80084 /* IMP: R-51513-12026 The last_insert_rowid() SQL function is a
80091 ** Implementation of the changes() SQL function.
80093 ** IMP: R-62073-11209 The changes() SQL function is a wrapper
80108 ** Implementation of the total_changes() SQL function. The return value is
80147 /* The correct SQL-92 behavior is for the LIKE operator to ignore
80301 ** Implementation of the like() SQL function. This function implements
80303 ** pattern and the second argument is the string. So, the SQL statements:
80387 /* IMP: R-48699-48617 This function is an SQL wrapper around the
80403 /* IMP: R-24470-31136 This function is an SQL wrapper around the
80422 /* IMP: R-39564-36305 The sqlite_compileoption_used() SQL
80446 /* IMP: R-04922-24076 The sqlite_compileoption_get() SQL function
80854 ** The SUM() function follows the (broken) SQL standard which means
81242 ** support to compiled SQL statements.
81519 ** child table of foreign key constraint pFKey. If an SQL UPDATE is executed
81662 ** code for an SQL UPDATE operation, this function may be called twice -
81710 /* Create an Expr object representing an SQL expression like:
82751 ** This routine is call to handle SQL of the following forms:
84274 ** Execute SQL code. Return one of the SQLITE_ success/failure
84278 ** If the SQL is a query, then for each row in the query result
84284 sqlite3 *db, /* The database on which the SQL executes */
84285 const char *zSql, /* The SQL to be executed */
84291 const char *zLeftover; /* Tail of unprocessed SQL */
84292 sqlite3_stmt *pStmt = 0; /* The current SQL statement */
84496 int (*complete)(const char*sql);
84497 int (*complete16)(const void*sql);
84612 const char *(*sql)(sqlite3_stmt*);
84812 #define sqlite3_sql sqlite3_api->sql
85496 ** to support legacy SQL code. The safety level used to be boolean
85697 /* Many of the flag-pragmas modify the code generated by the SQL
85699 ** compiled SQL statements after modifying a pragma value.
86780 ** of the schema used when compiling the SQL query matches the schema of
87027 ** argv[2] = SQL text for the CREATE statement.
87082 /* If the SQL column is blank it means this is an index that
87134 " sql text\n"
87144 " sql text\n"
87297 "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
87496 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
87500 const char *zSql, /* UTF-8 encoded SQL statement. */
87502 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
87663 const char *zSql, /* UTF-8 encoded SQL statement. */
87665 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
87727 ** version, the original SQL text is not saved in the prepared statement
87729 ** sqlite3_step(). In the new version, the original SQL text is retained
87735 const char *zSql, /* UTF-8 encoded SQL statement. */
87747 const char *zSql, /* UTF-8 encoded SQL statement. */
87761 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
87765 const void *zSql, /* UTF-8 encoded SQL statement. */
87767 int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
87807 ** version, the original SQL text is not saved in the prepared statement
87809 ** sqlite3_step(). In the new version, the original SQL text is retained
87815 const void *zSql, /* UTF-8 encoded SQL statement. */
87827 const void *zSql, /* UTF-8 encoded SQL statement. */
89237 ** that appear in the original SQL statement after the LIMIT and OFFSET
89348 ** Example 1: Consider a three-way compound SQL statement.
92016 ** the SQL statement is of the form:
92387 sqlite3 *db, /* The database on which the SQL executes */
92388 const char *zSql, /* The SQL to be executed */
94286 ** one column. Execute this as SQL on the same database.
94331 char *zSql = 0; /* SQL statements */
94346 sqlite3SetString(pzErrMsg, db,"cannot VACUUM - SQL statements in progress");
94442 "SELECT 'CREATE TABLE vacuum_db.' || substr(sql,14) "
94448 "SELECT 'CREATE INDEX vacuum_db.' || substr(sql,14)"
94449 " FROM sqlite_master WHERE sql LIKE 'CREATE INDEX %' ");
94452 "SELECT 'CREATE UNIQUE INDEX vacuum_db.' || substr(sql,21) "
94453 " FROM sqlite_master WHERE sql LIKE 'CREATE UNIQUE INDEX %'");
94491 " SELECT type, name, tbl_name, rootpage, sql"
94502 ** transaction is then committed, so the SQL level never knows it was
94503 ** opened for writing. This way, the SQL transaction used to create the
94555 /* Currently there is an SQL level transaction open on the vacuum
94937 "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q "
94958 ** the first time the virtual table is used in an SQL statement. This
95532 ** the WHERE clause of SQL statements. This module is responsible for
97224 /* The NOT INDEXED clause appears in the SQL. */
97821 ** is an SQL variable that currently has a non-NULL value bound to it,
97866 ** on t1(a, b), and the SQL query is:
97981 ** the SQL statement, then this function only considers plans using the
98567 ** SQLITE_AFF_NONE. This is to deal with SQL such as the following:
98676 ** SQL expression. Or, if all rows are scanned, NULL is returned.
99320 /* Initialize the rowset register to contain NULL. An SQL NULL is
99505 ** example, if the SQL is this:
103645 ** An tokenizer for SQL
103647 ** This file contains C code that splits an SQL input string up into
103705 ** or not a given identifier is really an SQL keyword. The same thing
103984 ** Ticket #1066. the SQL standard does not allow '$' in the
103985 ** middle of identfiers. But many SQL implementations do.
104227 case '@': /* For compatibility with MS SQL Server */
104287 ** Run the parser on the given SQL string. The parser structure is
104301 int mxSqlLen; /* Max length of an SQL string */
104447 ** An tokenizer for SQL
104486 ** Return TRUE if the given SQL string ends in a semicolon.
104496 ** (1) START At the beginning or end of an SQL statement. This routine
104524 ** (2) tkOTHER Any other SQL token.
104532 ** This means that a SQL string of all whitespace is invalid.
104597 case '-': { /* SQL-style comments from "--" to end of line */
104880 ** See also the "PRAGMA temp_store_directory" SQL command.
105468 ** SQL statements below, as the v-table implementation may be storing
105615 /* SQLITE_ERROR */ "SQL logic error or missing database",
105991 ** SQL statement.
106008 ** each SQL statement that is run.
107342 ** SQL Logic Test or SLT test module) can run the same SQL multiple times
108123 ** the following SQL is executed:
108734 ** Convert an SQL-style quoted string into a normal string by removing
108820 ** Construct one or more SQL statements from the format string given
108828 sqlite3 *db, /* Database in which to run SQL */
108829 const char *zFormat, /* Format string for SQL */
108882 char *zSql; /* SQL statement passed to declare_vtab() */
108978 char *zSql; /* SQL text "PRAGMA %Q.page_size" */
110362 sqlite3_stmt *pStmt = 0; /* SQL statement to scan %_segdir table */
111239 char *zSql; /* SQL statement used to access %_content */
111507 ** offsets() and optimize() SQL functions.
111516 sqlite3_context *pContext, /* SQL function call context */
111661 int nArg, /* Number of SQL function arguments */
111662 const char *zName, /* Name of SQL function */
112711 ** This is the implementation of a scalar SQL function used to test the
113871 ** Implementation of the SQL scalar function for accessing the underlying
114046 ** Implementation of a special SQL scalar function for testing tokenizers
114263 ** Set up SQL objects in database db used to access the contents of
114888 ** array apVal[] to the SQL statement identified by eStmt, the statement
114948 ** There is only ever one instance of this SQL statement compiled for
115225 ** table. The SQL for this statement is:
116558 sqlite3_stmt *pDelete; /* SQL statement to delete rows */
118962 /* Retreive the text stored in column iCol. If an SQL NULL is stored
119370 ** the right-hand-side of an SQL MATCH operator used to constrain an
120364 ** an sqlite3_rtree_geometry_callback() SQL user function.
121758 /* If azData[0] is not an SQL NULL value, it is the rowid of a
122024 ** The second argument to this function contains the text of an SQL statement
122290 ** registered SQL functions.
122374 ** * An implementation of the SQL regexp() function (and hence REGEXP
122377 ** * Implementations of the SQL scalar upper() and lower() functions
122499 ** Implementation of the like() SQL function. This function implements
122501 ** pattern and the second argument is the string. So, the SQL statements:
122552 ** the implementation of an SQL scalar function returns an error.
122581 ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
122668 ** of the locale to use. Passing an empty string ("") or SQL NULL value
122770 const char *zName; /* SQL Collation sequence name (eg. "japanese") */
