Add interfaces sqlite3_prepare_v3() and sqlite3_prepare16_v3() with the
extra prepFlags argument. Add the SQLITE_PREPARE_PERSISTENT option as one bit in that argument. FossilOrigin-Name: 4a25c5883380fe5990d8180adb58c3bdc7a3d081bc4c69cd4de3cd57074fb251
This commit is contained in:
+51
-11
@@ -513,7 +513,7 @@ static int sqlite3Prepare(
|
||||
sqlite3 *db, /* Database handle. */
|
||||
const char *zSql, /* UTF-8 encoded SQL statement. */
|
||||
int nBytes, /* Length of zSql in bytes. */
|
||||
int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
|
||||
u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
|
||||
Vdbe *pReprepare, /* VM being reprepared */
|
||||
sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
|
||||
const char **pzTail /* OUT: End of parsed string */
|
||||
@@ -530,6 +530,14 @@ static int sqlite3Prepare(
|
||||
/* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
|
||||
assert( sqlite3_mutex_held(db->mutex) );
|
||||
|
||||
/* For a long-term use prepared statement avoid the use of
|
||||
** lookaside memory.
|
||||
*/
|
||||
if( prepFlags & SQLITE_PREPARE_PERSISTENT ){
|
||||
sParse.disableLookaside++;
|
||||
db->lookaside.bDisable++;
|
||||
}
|
||||
|
||||
/* Check to verify that it is possible to get a read lock on all
|
||||
** database schemas. The inability to get a read lock indicates that
|
||||
** some other database connection is holding a write-lock, which in
|
||||
@@ -629,8 +637,7 @@ static int sqlite3Prepare(
|
||||
#endif
|
||||
|
||||
if( db->init.busy==0 ){
|
||||
Vdbe *pVdbe = sParse.pVdbe;
|
||||
sqlite3VdbeSetSql(pVdbe, zSql, (int)(sParse.zTail-zSql), saveSqlFlag);
|
||||
sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags);
|
||||
}
|
||||
if( sParse.pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
|
||||
sqlite3VdbeFinalize(sParse.pVdbe);
|
||||
@@ -664,7 +671,7 @@ static int sqlite3LockAndPrepare(
|
||||
sqlite3 *db, /* Database handle. */
|
||||
const char *zSql, /* UTF-8 encoded SQL statement. */
|
||||
int nBytes, /* Length of zSql in bytes. */
|
||||
int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
|
||||
u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
|
||||
Vdbe *pOld, /* VM being reprepared */
|
||||
sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
|
||||
const char **pzTail /* OUT: End of parsed string */
|
||||
@@ -680,10 +687,10 @@ static int sqlite3LockAndPrepare(
|
||||
}
|
||||
sqlite3_mutex_enter(db->mutex);
|
||||
sqlite3BtreeEnterAll(db);
|
||||
rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
|
||||
rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail);
|
||||
if( rc==SQLITE_SCHEMA ){
|
||||
sqlite3_finalize(*ppStmt);
|
||||
rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
|
||||
rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail);
|
||||
}
|
||||
sqlite3BtreeLeaveAll(db);
|
||||
sqlite3_mutex_leave(db->mutex);
|
||||
@@ -704,13 +711,15 @@ int sqlite3Reprepare(Vdbe *p){
|
||||
sqlite3_stmt *pNew;
|
||||
const char *zSql;
|
||||
sqlite3 *db;
|
||||
u8 prepFlags;
|
||||
|
||||
assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
|
||||
zSql = sqlite3_sql((sqlite3_stmt *)p);
|
||||
assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
|
||||
db = sqlite3VdbeDb(p);
|
||||
assert( sqlite3_mutex_held(db->mutex) );
|
||||
rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
|
||||
prepFlags = sqlite3VdbePrepareFlags(p);
|
||||
rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
|
||||
if( rc ){
|
||||
if( rc==SQLITE_NOMEM ){
|
||||
sqlite3OomFault(db);
|
||||
@@ -756,7 +765,23 @@ int sqlite3_prepare_v2(
|
||||
const char **pzTail /* OUT: End of parsed string */
|
||||
){
|
||||
int rc;
|
||||
rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
|
||||
rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0,
|
||||
ppStmt,pzTail);
|
||||
assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
|
||||
return rc;
|
||||
}
|
||||
int sqlite3_prepare_v3(
|
||||
sqlite3 *db, /* Database handle. */
|
||||
const char *zSql, /* UTF-8 encoded SQL statement. */
|
||||
int nBytes, /* Length of zSql in bytes. */
|
||||
unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
|
||||
sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
|
||||
const char **pzTail /* OUT: End of parsed string */
|
||||
){
|
||||
int rc;
|
||||
rc = sqlite3LockAndPrepare(db,zSql,nBytes,
|
||||
SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
|
||||
0,ppStmt,pzTail);
|
||||
assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
|
||||
return rc;
|
||||
}
|
||||
@@ -770,7 +795,7 @@ static int sqlite3Prepare16(
|
||||
sqlite3 *db, /* Database handle. */
|
||||
const void *zSql, /* UTF-16 encoded SQL statement. */
|
||||
int nBytes, /* Length of zSql in bytes. */
|
||||
int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
|
||||
u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
|
||||
sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
|
||||
const void **pzTail /* OUT: End of parsed string */
|
||||
){
|
||||
@@ -798,7 +823,7 @@ static int sqlite3Prepare16(
|
||||
sqlite3_mutex_enter(db->mutex);
|
||||
zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
|
||||
if( zSql8 ){
|
||||
rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8);
|
||||
rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8);
|
||||
}
|
||||
|
||||
if( zTail8 && pzTail ){
|
||||
@@ -844,7 +869,22 @@ int sqlite3_prepare16_v2(
|
||||
const void **pzTail /* OUT: End of parsed string */
|
||||
){
|
||||
int rc;
|
||||
rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
|
||||
rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail);
|
||||
assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
|
||||
return rc;
|
||||
}
|
||||
int sqlite3_prepare16_v3(
|
||||
sqlite3 *db, /* Database handle. */
|
||||
const void *zSql, /* UTF-16 encoded SQL statement. */
|
||||
int nBytes, /* Length of zSql in bytes. */
|
||||
unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
|
||||
sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
|
||||
const void **pzTail /* OUT: End of parsed string */
|
||||
){
|
||||
int rc;
|
||||
rc = sqlite3Prepare16(db,zSql,nBytes,
|
||||
SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
|
||||
ppStmt,pzTail);
|
||||
assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
|
||||
return rc;
|
||||
}
|
||||
|
||||
+84
-36
@@ -235,7 +235,7 @@ int sqlite3_threadsafe(void);
|
||||
** [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
|
||||
** and [sqlite3_close_v2()] are its destructors. There are many other
|
||||
** interfaces (such as
|
||||
** [sqlite3_prepare_v2()], [sqlite3_create_function()], and
|
||||
** [sqlite3_prepare_v3()], [sqlite3_create_function()], and
|
||||
** [sqlite3_busy_timeout()] to name but three) that are methods on an
|
||||
** sqlite3 object.
|
||||
*/
|
||||
@@ -339,7 +339,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
|
||||
** METHOD: sqlite3
|
||||
**
|
||||
** The sqlite3_exec() interface is a convenience wrapper around
|
||||
** [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
|
||||
** [sqlite3_prepare_v3()], [sqlite3_step()], and [sqlite3_finalize()],
|
||||
** that allows an application to run multiple statements of SQL
|
||||
** without having to use a lot of C code.
|
||||
**
|
||||
@@ -2679,7 +2679,8 @@ void sqlite3_randomness(int N, void *P);
|
||||
** [database connection], supplied in the first argument.
|
||||
** ^The authorizer callback is invoked as SQL statements are being compiled
|
||||
** by [sqlite3_prepare()] or its variants [sqlite3_prepare_v2()],
|
||||
** [sqlite3_prepare16()] and [sqlite3_prepare16_v2()]. ^At various
|
||||
** [sqlite3_prepare_v3()], [sqlite3_prepare16()], [sqlite3_prepare16_v2()],
|
||||
** and [sqlite3_prepare16_v3()]. ^At various
|
||||
** points during the compilation process, as logic is being created
|
||||
** to perform various actions, the authorizer callback is invoked to
|
||||
** see if those actions are allowed. ^The authorizer callback should
|
||||
@@ -2688,12 +2689,12 @@ void sqlite3_randomness(int N, void *P);
|
||||
** compiled, or [SQLITE_DENY] to cause the entire SQL statement to be
|
||||
** rejected with an error. ^If the authorizer callback returns
|
||||
** any value other than [SQLITE_IGNORE], [SQLITE_OK], or [SQLITE_DENY]
|
||||
** then the [sqlite3_prepare_v2()] or equivalent call that triggered
|
||||
** then the [sqlite3_prepare_v3()] or equivalent call that triggered
|
||||
** the authorizer will fail with an error message.
|
||||
**
|
||||
** When the callback returns [SQLITE_OK], that means the operation
|
||||
** requested is ok. ^When the callback returns [SQLITE_DENY], the
|
||||
** [sqlite3_prepare_v2()] or equivalent call that triggered the
|
||||
** [sqlite3_prepare_v3()] or equivalent call that triggered the
|
||||
** authorizer will fail with an error message explaining that
|
||||
** access is denied.
|
||||
**
|
||||
@@ -2744,10 +2745,10 @@ void sqlite3_randomness(int N, void *P);
|
||||
**
|
||||
** The authorizer callback must not do anything that will modify
|
||||
** the database connection that invoked the authorizer callback.
|
||||
** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
|
||||
** Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their
|
||||
** database connections for the meaning of "modify" in this paragraph.
|
||||
**
|
||||
** ^When [sqlite3_prepare_v2()] is used to prepare a statement, the
|
||||
** ^When [sqlite3_prepare_v3()] is used to prepare a statement, the
|
||||
** statement might be re-prepared during [sqlite3_step()] due to a
|
||||
** schema change. Hence, the application should ensure that the
|
||||
** correct authorizer callback remains in place during the [sqlite3_step()].
|
||||
@@ -2756,7 +2757,7 @@ void sqlite3_randomness(int N, void *P);
|
||||
** [sqlite3_prepare()] or its variants. Authorization is not
|
||||
** performed during statement evaluation in [sqlite3_step()], unless
|
||||
** as stated in the previous paragraph, sqlite3_step() invokes
|
||||
** sqlite3_prepare_v2() to reprepare a statement after a schema change.
|
||||
** sqlite3_prepare_v3() to reprepare a statement after a schema change.
|
||||
*/
|
||||
int sqlite3_set_authorizer(
|
||||
sqlite3*,
|
||||
@@ -2992,7 +2993,7 @@ int sqlite3_trace_v2(
|
||||
**
|
||||
** The progress handler callback must not do anything that will modify
|
||||
** the database connection that invoked the progress handler.
|
||||
** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
|
||||
** Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their
|
||||
** database connections for the meaning of "modify" in this paragraph.
|
||||
**
|
||||
*/
|
||||
@@ -3346,7 +3347,7 @@ const char *sqlite3_errstr(int);
|
||||
** The life-cycle of a prepared statement object usually goes like this:
|
||||
**
|
||||
** <ol>
|
||||
** <li> Create the prepared statement object using [sqlite3_prepare_v2()].
|
||||
** <li> Create the prepared statement object using [sqlite3_prepare_v3()].
|
||||
** <li> Bind values to [parameters] using the sqlite3_bind_*()
|
||||
** interfaces.
|
||||
** <li> Run the SQL by calling [sqlite3_step()] one or more times.
|
||||
@@ -3428,7 +3429,7 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
|
||||
**
|
||||
** [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
|
||||
** <dd>The maximum number of instructions in a virtual machine program
|
||||
** used to implement an SQL statement. If [sqlite3_prepare_v2()] or
|
||||
** used to implement an SQL statement. If [sqlite3_prepare_v3()] or
|
||||
** the equivalent tries to allocate space for more than this many opcodes
|
||||
** in a single prepared statement, an SQLITE_NOMEM error is returned.</dd>)^
|
||||
**
|
||||
@@ -3468,6 +3469,24 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
|
||||
#define SQLITE_LIMIT_TRIGGER_DEPTH 10
|
||||
#define SQLITE_LIMIT_WORKER_THREADS 11
|
||||
|
||||
/*
|
||||
** CAPI3REF: Prepare Flags
|
||||
** KEYWORDS:
|
||||
**
|
||||
** These constants define various flags that can be passed into
|
||||
** the [sqlite3_prepare_v3()] interface.
|
||||
**
|
||||
** <dl>
|
||||
** [[SQLITE_PREPARE_PERSISTENT]] ^(<dt>SQLITE_PREPARE_PERSISTENT</dt>
|
||||
** <dd>The SQLITE_PREPARE_PERSISTENT flag causes [sqlite3_prepare_v3()]
|
||||
** to optimize the resulting prepared statement to be retained for a
|
||||
** relatively long amount of time.)^ ^Without this flag,
|
||||
** [sqlite3_prepare_v3()] assumes that the prepared statement will be used
|
||||
** just once or at most a few times and then destroyed using
|
||||
** [sqlite3_finalize()] relatively soon.
|
||||
** </dl>
|
||||
*/
|
||||
#define SQLITE_PREPARE_PERSISTENT 0x01
|
||||
|
||||
/*
|
||||
** CAPI3REF: Compiling An SQL Statement
|
||||
@@ -3483,9 +3502,10 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
|
||||
** [sqlite3_open16()]. The database connection must not have been closed.
|
||||
**
|
||||
** The second argument, "zSql", is the statement to be compiled, encoded
|
||||
** as either UTF-8 or UTF-16. The sqlite3_prepare() and sqlite3_prepare_v2()
|
||||
** interfaces use UTF-8, and sqlite3_prepare16() and sqlite3_prepare16_v2()
|
||||
** use UTF-16.
|
||||
** as either UTF-8 or UTF-16. The sqlite3_prepare(), sqlite3_prepare_v2(),
|
||||
** and sqlite3_prepare_v3()
|
||||
** interfaces use UTF-8, and sqlite3_prepare16(), sqlite3_prepare16_v2(),
|
||||
** and sqlite3_prepare16_v3() use UTF-16.
|
||||
**
|
||||
** ^If the nByte argument is negative, then zSql is read up to the
|
||||
** first zero terminator. ^If nByte is positive, then it is the
|
||||
@@ -3512,10 +3532,11 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
|
||||
** ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
|
||||
** otherwise an [error code] is returned.
|
||||
**
|
||||
** The sqlite3_prepare_v2() and sqlite3_prepare16_v2() interfaces are
|
||||
** recommended for all new programs. The two older interfaces are retained
|
||||
** for backwards compatibility, but their use is discouraged.
|
||||
** ^In the "v2" interfaces, the prepared statement
|
||||
** The sqlite3_prepare_v2(), sqlite3_prepare_v3(), sqlite3_prepare16_v2(),
|
||||
** and sqlite3_prepare16_v3() interfaces are recommended for all new programs.
|
||||
** The older interfaces are retained (sqlite3_prepare() and sqlite3_prepare16())
|
||||
** are retained for backwards compatibility, but their use is discouraged.
|
||||
** ^In the "vX" interfaces, the prepared statement
|
||||
** that is returned (the [sqlite3_stmt] object) contains a copy of the
|
||||
** original SQL text. This causes the [sqlite3_step()] interface to
|
||||
** behave differently in three ways:
|
||||
@@ -3548,6 +3569,12 @@ int sqlite3_limit(sqlite3*, int id, int newVal);
|
||||
** or [GLOB] operator or if the parameter is compared to an indexed column
|
||||
** and the [SQLITE_ENABLE_STAT3] compile-time option is enabled.
|
||||
** </li>
|
||||
**
|
||||
** <p>^sqlite3_prepare_v3() differs from sqlite3_prepare_v2() only in having
|
||||
** the extra prepFlags parameter, which is a bit array consisting of zero or
|
||||
** more of the [SQLITE_PREPARE_PERSISTENT|SQLITE_PREPARE_*] flags. ^The
|
||||
** sqlite3_prepare_v2() interface works exactly the same as
|
||||
** sqlite3_prepare_v3() with a zero prepFlags parameter.
|
||||
** </ol>
|
||||
*/
|
||||
int sqlite3_prepare(
|
||||
@@ -3564,6 +3591,14 @@ int sqlite3_prepare_v2(
|
||||
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
||||
const char **pzTail /* OUT: Pointer to unused portion of zSql */
|
||||
);
|
||||
int sqlite3_prepare_v3(
|
||||
sqlite3 *db, /* Database handle */
|
||||
const char *zSql, /* SQL statement, UTF-8 encoded */
|
||||
int nByte, /* Maximum length of zSql in bytes. */
|
||||
unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */
|
||||
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
||||
const char **pzTail /* OUT: Pointer to unused portion of zSql */
|
||||
);
|
||||
int sqlite3_prepare16(
|
||||
sqlite3 *db, /* Database handle */
|
||||
const void *zSql, /* SQL statement, UTF-16 encoded */
|
||||
@@ -3578,6 +3613,14 @@ int sqlite3_prepare16_v2(
|
||||
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
||||
const void **pzTail /* OUT: Pointer to unused portion of zSql */
|
||||
);
|
||||
int sqlite3_prepare16_v3(
|
||||
sqlite3 *db, /* Database handle */
|
||||
const void *zSql, /* SQL statement, UTF-16 encoded */
|
||||
int nByte, /* Maximum length of zSql in bytes. */
|
||||
unsigned int prepFalgs, /* Zero or more SQLITE_PREPARE_ flags */
|
||||
sqlite3_stmt **ppStmt, /* OUT: Statement handle */
|
||||
const void **pzTail /* OUT: Pointer to unused portion of zSql */
|
||||
);
|
||||
|
||||
/*
|
||||
** CAPI3REF: Retrieving Statement SQL
|
||||
@@ -3585,7 +3628,8 @@ int sqlite3_prepare16_v2(
|
||||
**
|
||||
** ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8
|
||||
** SQL text used to create [prepared statement] P if P was
|
||||
** created by either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()].
|
||||
** created by [sqlite3_prepare_v2()], [sqlite3_prepare_v3()],
|
||||
** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()].
|
||||
** ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
|
||||
** string containing the SQL text of prepared statement P with
|
||||
** [bound parameters] expanded.
|
||||
@@ -3731,7 +3775,7 @@ typedef struct sqlite3_context sqlite3_context;
|
||||
** KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
|
||||
** METHOD: sqlite3_stmt
|
||||
**
|
||||
** ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
|
||||
** ^(In the SQL statement text input to [sqlite3_prepare_v3()] and its variants,
|
||||
** literals may be replaced by a [parameter] that matches one of following
|
||||
** templates:
|
||||
**
|
||||
@@ -3750,7 +3794,7 @@ typedef struct sqlite3_context sqlite3_context;
|
||||
**
|
||||
** ^The first argument to the sqlite3_bind_*() routines is always
|
||||
** a pointer to the [sqlite3_stmt] object returned from
|
||||
** [sqlite3_prepare_v2()] or its variants.
|
||||
** [sqlite3_prepare_v3()] or its variants.
|
||||
**
|
||||
** ^The second argument is the index of the SQL parameter to be set.
|
||||
** ^The leftmost SQL parameter has an index of 1. ^When the same named
|
||||
@@ -3887,8 +3931,8 @@ int sqlite3_bind_parameter_count(sqlite3_stmt*);
|
||||
** ^If the value N is out of range or if the N-th parameter is
|
||||
** nameless, then NULL is returned. ^The returned string is
|
||||
** always in UTF-8 encoding even if the named parameter was
|
||||
** originally specified as UTF-16 in [sqlite3_prepare16()] or
|
||||
** [sqlite3_prepare16_v2()].
|
||||
** originally specified as UTF-16 in [sqlite3_prepare16()],
|
||||
** [sqlite3_prepare16_v2()], or [sqlite3_prepare16_v3()].
|
||||
**
|
||||
** See also: [sqlite3_bind_blob|sqlite3_bind()],
|
||||
** [sqlite3_bind_parameter_count()], and
|
||||
@@ -3905,7 +3949,8 @@ const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);
|
||||
** parameter to [sqlite3_bind_blob|sqlite3_bind()]. ^A zero
|
||||
** is returned if no matching parameter is found. ^The parameter
|
||||
** name must be given in UTF-8 even if the original statement
|
||||
** was prepared from UTF-16 text using [sqlite3_prepare16_v2()].
|
||||
** was prepared from UTF-16 text using [sqlite3_prepare16_v2()] or
|
||||
** [sqlite3_prepare16_v3()].
|
||||
**
|
||||
** See also: [sqlite3_bind_blob|sqlite3_bind()],
|
||||
** [sqlite3_bind_parameter_count()], and
|
||||
@@ -4059,16 +4104,18 @@ const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
|
||||
** CAPI3REF: Evaluate An SQL Statement
|
||||
** METHOD: sqlite3_stmt
|
||||
**
|
||||
** After a [prepared statement] has been prepared using either
|
||||
** [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] or one of the legacy
|
||||
** After a [prepared statement] has been prepared using any of
|
||||
** [sqlite3_prepare_v2()], [sqlite3_prepare_v3()], [sqlite3_prepare16_v2()],
|
||||
** or [sqlite3_prepare16_v3()] or one of the legacy
|
||||
** interfaces [sqlite3_prepare()] or [sqlite3_prepare16()], this function
|
||||
** must be called one or more times to evaluate the statement.
|
||||
**
|
||||
** The details of the behavior of the sqlite3_step() interface depend
|
||||
** on whether the statement was prepared using the newer "v2" interface
|
||||
** [sqlite3_prepare_v2()] and [sqlite3_prepare16_v2()] or the older legacy
|
||||
** interface [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the
|
||||
** new "v2" interface is recommended for new applications but the legacy
|
||||
** on whether the statement was prepared using the newer "vX" interfaces
|
||||
** [sqlite3_prepare_v3()], [sqlite3_prepare_v2()], [sqlite3_prepare16_v3()],
|
||||
** [sqlite3_prepare16_v2()] or the older legacy
|
||||
** interfaces [sqlite3_prepare()] and [sqlite3_prepare16()]. The use of the
|
||||
** new "vX" interface is recommended for new applications but the legacy
|
||||
** interface will continue to be supported.
|
||||
**
|
||||
** ^In the legacy interface, the return value will be either [SQLITE_BUSY],
|
||||
@@ -4129,10 +4176,11 @@ const void *sqlite3_column_decltype16(sqlite3_stmt*,int);
|
||||
** specific [error codes] that better describes the error.
|
||||
** We admit that this is a goofy design. The problem has been fixed
|
||||
** with the "v2" interface. If you prepare all of your SQL statements
|
||||
** using either [sqlite3_prepare_v2()] or [sqlite3_prepare16_v2()] instead
|
||||
** using [sqlite3_prepare_v3()] or [sqlite3_prepare_v2()]
|
||||
** or [sqlite3_prepare16_v2()] or [sqlite3_prepare16_v3()] instead
|
||||
** of the legacy [sqlite3_prepare()] and [sqlite3_prepare16()] interfaces,
|
||||
** then the more specific [error codes] are returned directly
|
||||
** by sqlite3_step(). The use of the "v2" interface is recommended.
|
||||
** by sqlite3_step(). The use of the "vX" interfaces is recommended.
|
||||
*/
|
||||
int sqlite3_step(sqlite3_stmt*);
|
||||
|
||||
@@ -4197,7 +4245,7 @@ int sqlite3_data_count(sqlite3_stmt *pStmt);
|
||||
** ^These routines return information about a single column of the current
|
||||
** result row of a query. ^In every case the first argument is a pointer
|
||||
** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
|
||||
** that was returned from [sqlite3_prepare_v2()] or one of its variants)
|
||||
** that was returned from [sqlite3_prepare_v3()] or one of its variants)
|
||||
** and the second argument is the index of the column for which information
|
||||
** should be returned. ^The leftmost column of the result set has the index 0.
|
||||
** ^The number of columns in the result can be determined using
|
||||
@@ -5321,7 +5369,7 @@ int sqlite3_get_autocommit(sqlite3*);
|
||||
** to which a [prepared statement] belongs. ^The [database connection]
|
||||
** returned by sqlite3_db_handle is the same [database connection]
|
||||
** that was the first argument
|
||||
** to the [sqlite3_prepare_v2()] call (or its variants) that was used to
|
||||
** to the [sqlite3_prepare_v3()] call (or its variants) that was used to
|
||||
** create the statement in the first place.
|
||||
*/
|
||||
sqlite3 *sqlite3_db_handle(sqlite3_stmt*);
|
||||
@@ -5397,7 +5445,7 @@ sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);
|
||||
** completion of the [sqlite3_step()] call that triggered the commit
|
||||
** or rollback hook in the first place.
|
||||
** Note that running any other SQL statements, including SELECT statements,
|
||||
** or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify
|
||||
** or merely calling [sqlite3_prepare_v3()] and [sqlite3_step()] will modify
|
||||
** the database connections for the meaning of "modify" in this paragraph.
|
||||
**
|
||||
** ^Registering a NULL function disables the callback.
|
||||
@@ -5457,7 +5505,7 @@ void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);
|
||||
** the database connection that invoked the update hook. Any actions
|
||||
** to modify the database connection must be deferred until after the
|
||||
** completion of the [sqlite3_step()] call that triggered the update hook.
|
||||
** Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
|
||||
** Note that [sqlite3_prepare_v3()] and [sqlite3_step()] both modify their
|
||||
** database connections for the meaning of "modify" in this paragraph.
|
||||
**
|
||||
** ^The sqlite3_update_hook(D,C,P) function
|
||||
|
||||
+7
-1
@@ -1214,12 +1214,18 @@ static int dbPrepare(
|
||||
sqlite3_stmt **ppStmt, /* OUT: Prepared statement */
|
||||
const char **pzOut /* OUT: Pointer to next SQL statement */
|
||||
){
|
||||
unsigned int prepFlags = 0;
|
||||
#ifdef SQLITE_TEST
|
||||
if( pDb->bLegacyPrepare ){
|
||||
return sqlite3_prepare(pDb->db, zSql, -1, ppStmt, pzOut);
|
||||
}
|
||||
#endif
|
||||
return sqlite3_prepare_v2(pDb->db, zSql, -1, ppStmt, pzOut);
|
||||
/* If the statement cache is large, use the SQLITE_PREPARE_PERSISTENT
|
||||
** flags, which uses less lookaside memory. But if the cache is small,
|
||||
** omit that flag to make full use of lookaside */
|
||||
if( pDb->maxStmt>5 ) prepFlags = SQLITE_PREPARE_PERSISTENT;
|
||||
|
||||
return sqlite3_prepare_v3(pDb->db, zSql, -1, prepFlags, ppStmt, pzOut);
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
+8
-1
@@ -165,6 +165,12 @@ typedef struct VdbeOpList VdbeOpList;
|
||||
*/
|
||||
#include "opcodes.h"
|
||||
|
||||
/*
|
||||
** Additional non-public SQLITE_PREPARE_* flags
|
||||
*/
|
||||
#define SQLITE_PREPARE_SAVESQL 0x80 /* Preserve SQL text */
|
||||
#define SQLITE_PREPARE_MASK 0x0f /* Mask of public flags */
|
||||
|
||||
/*
|
||||
** Prototypes for the VDBE interface. See comments on the implementation
|
||||
** for a description of what each of these routines does.
|
||||
@@ -222,7 +228,8 @@ void sqlite3VdbeSetNumCols(Vdbe*,int);
|
||||
int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
|
||||
void sqlite3VdbeCountChanges(Vdbe*);
|
||||
sqlite3 *sqlite3VdbeDb(Vdbe*);
|
||||
void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, int);
|
||||
u8 sqlite3VdbePrepareFlags(Vdbe*);
|
||||
void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8);
|
||||
void sqlite3VdbeSwap(Vdbe*,Vdbe*);
|
||||
VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*, int*, int*);
|
||||
sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe*, int, u8);
|
||||
|
||||
+1
-1
@@ -382,6 +382,7 @@ struct Vdbe {
|
||||
u16 nResColumn; /* Number of columns in one row of the result set */
|
||||
u8 errorAction; /* Recovery action to do in case of an error */
|
||||
u8 minWriteFileFormat; /* Minimum file format for writable database files */
|
||||
u8 prepFlags; /* SQLITE_PREPARE_* flags */
|
||||
bft expired:1; /* True if the VM needs to be recompiled */
|
||||
bft doingRerun:1; /* True if rerunning after an auto-reprepare */
|
||||
bft explain:2; /* True if EXPLAIN present on SQL command */
|
||||
@@ -390,7 +391,6 @@ struct Vdbe {
|
||||
bft usesStmtJournal:1; /* True if uses a statement journal */
|
||||
bft readOnly:1; /* True for statements that do not write */
|
||||
bft bIsReader:1; /* True for statements that read */
|
||||
bft isPrepareV2:1; /* True if prepared with prepare_v2() */
|
||||
yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
|
||||
yDbMask lockMask; /* Subset of btreeMask that requires a lock */
|
||||
u32 aCounter[5]; /* Counters used by sqlite3_stmt_status() */
|
||||
|
||||
+9
-6
@@ -154,7 +154,7 @@ int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
|
||||
sqlite3VdbeMemRelease(&p->aVar[i]);
|
||||
p->aVar[i].flags = MEM_Null;
|
||||
}
|
||||
assert( p->isPrepareV2 || p->expmask==0 );
|
||||
assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
|
||||
if( p->expmask ){
|
||||
p->expired = 1;
|
||||
}
|
||||
@@ -633,8 +633,11 @@ end_of_step:
|
||||
|| (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE
|
||||
);
|
||||
assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp );
|
||||
if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
|
||||
/* If this statement was prepared using sqlite3_prepare_v2(), and an
|
||||
if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0
|
||||
&& rc!=SQLITE_ROW
|
||||
&& rc!=SQLITE_DONE
|
||||
){
|
||||
/* If this statement was prepared using saved SQL and an
|
||||
** error has occurred, then return the error code in p->rc to the
|
||||
** caller. Set the error code in the database handle to the same value.
|
||||
*/
|
||||
@@ -1273,7 +1276,7 @@ static int vdbeUnbind(Vdbe *p, int i){
|
||||
** as if there had been a schema change, on the first sqlite3_step() call
|
||||
** following any change to the bindings of that parameter.
|
||||
*/
|
||||
assert( p->isPrepareV2 || p->expmask==0 );
|
||||
assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
|
||||
if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<<i))!=0 ){
|
||||
p->expired = 1;
|
||||
}
|
||||
@@ -1539,11 +1542,11 @@ int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
|
||||
if( pFrom->nVar!=pTo->nVar ){
|
||||
return SQLITE_ERROR;
|
||||
}
|
||||
assert( pTo->isPrepareV2 || pTo->expmask==0 );
|
||||
assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
|
||||
if( pTo->expmask ){
|
||||
pTo->expired = 1;
|
||||
}
|
||||
assert( pFrom->isPrepareV2 || pFrom->expmask==0 );
|
||||
assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 );
|
||||
if( pFrom->expmask ){
|
||||
pFrom->expired = 1;
|
||||
}
|
||||
|
||||
+13
-8
@@ -54,16 +54,14 @@ void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
|
||||
/*
|
||||
** Remember the SQL string for a prepared statement.
|
||||
*/
|
||||
void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, int isPrepareV2){
|
||||
assert( isPrepareV2==1 || isPrepareV2==0 );
|
||||
void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){
|
||||
if( p==0 ) return;
|
||||
if( !isPrepareV2 ) p->expmask = 0;
|
||||
#if defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_ENABLE_SQLLOG)
|
||||
if( !isPrepareV2 ) return;
|
||||
#endif
|
||||
p->prepFlags = prepFlags;
|
||||
if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
|
||||
p->expmask = 0;
|
||||
}
|
||||
assert( p->zSql==0 );
|
||||
p->zSql = sqlite3DbStrNDup(p->db, z, n);
|
||||
p->isPrepareV2 = (u8)isPrepareV2;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -85,8 +83,8 @@ void sqlite3VdbeSwap(Vdbe *pA, Vdbe *pB){
|
||||
zTmp = pA->zSql;
|
||||
pA->zSql = pB->zSql;
|
||||
pB->zSql = zTmp;
|
||||
pB->isPrepareV2 = pA->isPrepareV2;
|
||||
pB->expmask = pA->expmask;
|
||||
pB->prepFlags = pA->prepFlags;
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -4530,6 +4528,13 @@ sqlite3 *sqlite3VdbeDb(Vdbe *v){
|
||||
return v->db;
|
||||
}
|
||||
|
||||
/*
|
||||
** Return the SQLITE_PREPARE flags for a Vdbe.
|
||||
*/
|
||||
u8 sqlite3VdbePrepareFlags(Vdbe *v){
|
||||
return v->prepFlags;
|
||||
}
|
||||
|
||||
/*
|
||||
** Return a pointer to an sqlite3_value structure containing the value bound
|
||||
** parameter iVar of VM v. Except, if the value is an SQL NULL, return
|
||||
|
||||
Reference in New Issue
Block a user