The SQLITE_PREPARE_NO_VTAB flag causes the SQL compiler
** to return an error (error code SQLITE_ERROR) if the statement uses
** any virtual tables.
+**
+** [[SQLITE_PREPARE_CACHE]] | SQLITE_PREPARE_CACHE
+** The SQLITE_PREPARE_CACHE flag gives SQLite permission to attempt
+** to cache the prepared statement after it is
+** [sqlite3_finalized|finalized] and attempt to reuse it as the
+** return value for the next call to a [sqlite3_prepare()] that has
+** the same SQL. This flag also implies [SQLITE_PREPARE_PERSISTENT].
**
*/
#define SQLITE_PREPARE_PERSISTENT 0x01
#define SQLITE_PREPARE_NORMALIZE 0x02
#define SQLITE_PREPARE_NO_VTAB 0x04
+#define SQLITE_PREPARE_CACHE 0x08
/*
** CAPI3REF: Compiling An SQL Statement
@@ -8576,6 +8630,7 @@ int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);
#define SQLITE_STMTSTATUS_RUN 6
#define SQLITE_STMTSTATUS_FILTER_MISS 7
#define SQLITE_STMTSTATUS_FILTER_HIT 8
+#define SQLITE_STMTSTATUS_STATE 98
#define SQLITE_STMTSTATUS_MEMUSED 99
/*
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index 21d15378f1..b7fe75855f 100644
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -347,6 +347,16 @@
# define SQLITE_DEFAULT_MEMSTATUS 1
#endif
+/*
+** Set the default maximum statement cache size
+*/
+#if !defined(SQLITE_DEFAULT_STMTCACHE_SIZE)
+# define SQLITE_DEFAULT_STMTCACHE_SIZE 10
+#endif
+#if SQLITE_DEFAULT_STMTCACHE_SIZE<0 || SQLITE_DEFAULT_STMTCACHE_SIZE>254
+# error SQLITE_DEFAULT_STMTCACHE_SIZE must be between 0 and 254
+#endif
+
/*
** Exactly one of the following macros must be defined in order to
** specify which memory allocation subsystem to use.
@@ -1560,6 +1570,7 @@ struct sqlite3 {
u8 noSharedCache; /* True if no shared-cache backends */
u8 nSqlExec; /* Number of pending OP_SqlExec opcodes */
u8 eOpenState; /* Current condition of the connection */
+ u8 mxCache, nCache; /* Max and current size of statement cache */
int nextPagesize; /* Pagesize after VACUUM if >0 */
i64 nChange; /* Value returned by sqlite3_changes() */
i64 nTotalChange; /* Value returned by sqlite3_total_changes() */
diff --git a/src/vdbe.h b/src/vdbe.h
index eb1445f1db..324e811e08 100644
--- a/src/vdbe.h
+++ b/src/vdbe.h
@@ -262,7 +262,9 @@ int sqlite3VdbeSetColName(Vdbe*, int, int, const char *, void(*)(void*));
void sqlite3VdbeCountChanges(Vdbe*);
sqlite3 *sqlite3VdbeDb(Vdbe*);
u8 sqlite3VdbePrepareFlags(Vdbe*);
-void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8);
+void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8, u32);
+Vdbe *sqlite3VdbeFindInStmtCache(sqlite3*,const char*,int,u32*);
+void sqlite3VdbeChangeStmtCacheSize(sqlite3*,int);
#ifdef SQLITE_ENABLE_NORMALIZE
void sqlite3VdbeAddDblquoteStr(sqlite3*,Vdbe*,const char*);
int sqlite3VdbeUsesDoubleQuotedString(Vdbe*,const char*);
diff --git a/src/vdbeInt.h b/src/vdbeInt.h
index 0c6301c8f1..a17e1e3ba8 100644
--- a/src/vdbeInt.h
+++ b/src/vdbeInt.h
@@ -470,6 +470,8 @@ struct Vdbe {
yDbMask btreeMask; /* Bitmask of db->aDb[] entries referenced */
yDbMask lockMask; /* Subset of btreeMask that requires a lock */
u32 aCounter[9]; /* Counters used by sqlite3_stmt_status() */
+ u32 hSql; /* Hash for zSql */
+ int nSql; /* Number of bytes in zSql[] */
char *zSql; /* Text of the SQL statement that generated this */
#ifdef SQLITE_ENABLE_NORMALIZE
char *zNormSql; /* Normalization of the associated SQL statement */
@@ -496,6 +498,7 @@ struct Vdbe {
#define VDBE_READY_STATE 1 /* Ready to run but not yet started */
#define VDBE_RUN_STATE 2 /* Run in progress */
#define VDBE_HALT_STATE 3 /* Finished. Need reset() or finalize() */
+#define VDBE_CACHE_STATE 4 /* In statement cache */
/*
** Structure used to store the context required by the
@@ -653,9 +656,11 @@ int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);
#ifdef SQLITE_DEBUG
void sqlite3VdbeIncrWriteCounter(Vdbe*, VdbeCursor*);
void sqlite3VdbeAssertAbortable(Vdbe*);
+ void sqlite3VdbeCheckActiveVdbeCount(sqlite3*);
#else
# define sqlite3VdbeIncrWriteCounter(V,C)
# define sqlite3VdbeAssertAbortable(V)
+# define sqlite3VdbeCheckActiveVdbeCount(D)
#endif
#if !defined(SQLITE_OMIT_SHARED_CACHE)
diff --git a/src/vdbeapi.c b/src/vdbeapi.c
index 6c5f7562b3..f42d8ca6f3 100644
--- a/src/vdbeapi.c
+++ b/src/vdbeapi.c
@@ -110,7 +110,20 @@ int sqlite3_finalize(sqlite3_stmt *pStmt){
checkProfileCallback(db, v);
assert( v->eVdbeState>=VDBE_READY_STATE );
rc = sqlite3VdbeReset(v);
- sqlite3VdbeDelete(v);
+ if( rc==SQLITE_OK
+ && v->hSql>0
+ && db->mxCache>0
+ && v->expired==0
+ ){
+ v->eVdbeState = VDBE_CACHE_STATE;
+ db->nCache++;
+ if( db->nCache>db->mxCache){
+ sqlite3VdbeChangeStmtCacheSize(db, db->mxCache);
+ }
+ }else{
+ sqlite3VdbeDelete(v);
+ }
+ sqlite3VdbeCheckActiveVdbeCount(db);
rc = sqlite3ApiExit(db, rc);
sqlite3LeaveMutexAndCloseZombie(db);
}
@@ -689,6 +702,7 @@ static int sqlite3Step(Vdbe *p){
if( p->bIsReader ) db->nVdbeRead++;
p->pc = 0;
p->eVdbeState = VDBE_RUN_STATE;
+ sqlite3VdbeCheckActiveVdbeCount(db);
}else
if( ALWAYS(p->eVdbeState==VDBE_HALT_STATE) ){
@@ -1842,6 +1856,8 @@ int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
db->pnBytesFreed = 0;
db->lookaside.pEnd = db->lookaside.pTrueEnd;
sqlite3_mutex_leave(db->mutex);
+ }else if( op==SQLITE_STMTSTATUS_STATE ){
+ v = pVdbe->eVdbeState;
}else{
v = pVdbe->aCounter[op];
if( resetFlag ) pVdbe->aCounter[op] = 0;
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index a4b4516c04..916b2277e3 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -67,7 +67,13 @@ void sqlite3VdbeError(Vdbe *p, const char *zFormat, ...){
/*
** Remember the SQL string for a prepared statement.
*/
-void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){
+void sqlite3VdbeSetSql(
+ Vdbe *p, /* The VDBE whose SQL text is to be set */
+ const char *z, /* the SQL text */
+ int n, /* Number of bytes in z[] */
+ u8 prepFlags, /* prepFlags */
+ u32 hSql /* Hash of z[] used for fast cache lookups */
+){
if( p==0 ) return;
p->prepFlags = prepFlags;
if( (prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
@@ -75,8 +81,61 @@ void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){
}
assert( p->zSql==0 );
p->zSql = sqlite3DbStrNDup(p->db, z, n);
+ p->nSql = n;
+ p->hSql = hSql;
+}
+
+/*
+** Search for a cached VDBE that that implements the given SQL.
+*/
+Vdbe *sqlite3VdbeFindInStmtCache(
+ sqlite3 *db, /* The database connection holding the cache */
+ const char *zSql, /* Input SQL text */
+ int nSql, /* Size of zSql[] in bytes */
+ u32 *phSql /* Write the hash value here if not found */
+){
+ int i; /* Loop counter */
+ Vdbe *pCache; /* Candidate statement */
+ u32 c; /* One character of SQL input */
+ u32 hSql; /* A hash of the SQL input */
+ int n; /* Number of SQL input characters to be hashed */
+
+ hSql = 0;
+ n = nSql;
+ if( n>100 ) n = 100;
+ for(i=0; inCache ){
+ for(pCache = db->pVdbe; pCache; pCache=pCache->pVNext){
+ if( pCache->hSql==hSql
+ && pCache->eVdbeState==VDBE_CACHE_STATE
+ && pCache->nSql==nSql
+ && strncmp(zSql, pCache->zSql, nSql)==0
+ ){
+ pCache->eVdbeState = VDBE_READY_STATE;
+ db->nCache--;
+ if( pCache!=db->pVdbe ){
+ if( pCache->pVNext ){
+ pCache->pVNext->ppVPrev = pCache->ppVPrev;
+ }
+ *pCache->ppVPrev = pCache->pVNext;
+ pCache->pVNext = db->pVdbe;
+ pCache->ppVPrev = &db->pVdbe;
+ db->pVdbe->ppVPrev = &pCache->pVNext;
+ db->pVdbe = pCache;
+ }
+ sqlite3VdbeCheckActiveVdbeCount(db);
+ return pCache;
+ }
+ }
+ }
+ *phSql = hSql;
+ return 0;
}
+
#ifdef SQLITE_ENABLE_NORMALIZE
/*
** Add a new element to the Vdbe->pDblStr list.
@@ -3008,7 +3067,7 @@ static int vdbeCommit(sqlite3 *db, Vdbe *p){
** This is a no-op if NDEBUG is defined.
*/
#ifndef NDEBUG
-static void checkActiveVdbeCnt(sqlite3 *db){
+void sqlite3VdbeCheckActiveVdbeCount(sqlite3 *db){
Vdbe *p;
int cnt = 0;
int nWrite = 0;
@@ -3026,10 +3085,36 @@ static void checkActiveVdbeCnt(sqlite3 *db){
assert( nWrite==db->nVdbeWrite );
assert( nRead==db->nVdbeRead );
}
-#else
-#define checkActiveVdbeCnt(x)
#endif
+/*
+** Attempt to change the statement cache size. If the statement cache
+** size is reduced remove excess elements from the cache.
+**
+** The argument is the *desired* new statement cache size. The new
+** statement cache size will not necessarily be the same size.
+*/
+void sqlite3VdbeChangeStmtCacheSize(sqlite3 *db, int szDesired){
+ assert( szDesired>=0 );
+ if( szDesired>100 ) szDesired = 100;
+ if( db->nCache>szDesired ){
+ Vdbe *p, *pNext;
+ int n = szDesired;
+ for(p=db->pVdbe; p; p=pNext){
+ pNext = p->pVNext;
+ if( p->hSql==0 ) continue;
+ if( p->eVdbeState!=VDBE_CACHE_STATE ) continue;
+ if( n>0 ){ n--; continue; }
+ sqlite3VdbeDelete(p);
+ assert( db->nCache>szDesired );
+ db->nCache--;
+ }
+ assert( db->nCache==szDesired );
+ }
+ db->mxCache = szDesired;
+ sqlite3VdbeCheckActiveVdbeCount(db);
+}
+
/*
** If the Vdbe passed as the first argument opened a statement-transaction,
** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or
@@ -3158,7 +3243,7 @@ int sqlite3VdbeHalt(Vdbe *p){
p->rc = SQLITE_NOMEM_BKPT;
}
closeAllCursors(p);
- checkActiveVdbeCnt(db);
+ sqlite3VdbeCheckActiveVdbeCount(db);
/* No commit or rollback needed if the program never started or if the
** SQL statement does not read or write a database file. */
@@ -3317,7 +3402,7 @@ int sqlite3VdbeHalt(Vdbe *p){
assert( db->nVdbeRead>=db->nVdbeWrite );
assert( db->nVdbeWrite>=0 );
p->eVdbeState = VDBE_HALT_STATE;
- checkActiveVdbeCnt(db);
+ sqlite3VdbeCheckActiveVdbeCount(db);
if( db->mallocFailed ){
p->rc = SQLITE_NOMEM_BKPT;
}
@@ -5104,6 +5189,12 @@ void sqlite3ExpirePreparedStatements(sqlite3 *db, int iCode){
for(p = db->pVdbe; p; p=p->pVNext){
p->expired = iCode+1;
}
+ if( db->nCache>0 ){
+ u8 mxCache = db->mxCache;
+ sqlite3VdbeChangeStmtCacheSize(db, 0);
+ assert( db->nCache==0 );
+ db->mxCache = mxCache;
+ }
}
/*
diff --git a/test/speedtest1.c b/test/speedtest1.c
index 83c503c8c7..e782e7313c 100644
--- a/test/speedtest1.c
+++ b/test/speedtest1.c
@@ -25,6 +25,7 @@ static const char zHelp[] =
" --output FILE Store SQL output in FILE\n"
" --pagesize N Set the page size to N\n"
" --pcache N SZ Configure N pages of pagecache each of size SZ bytes\n"
+ " --persist Use the SQLITE_PREPARE_PERSISTENT flag\n"
" --primarykey Use PRIMARY KEY instead of UNIQUE where appropriate\n"
" --repeat N Repeat each SELECT N times (default: 1)\n"
" --reprepare Reprepare each statement upon every invocation\n"
@@ -87,6 +88,7 @@ static struct Global {
sqlite3_int64 iTotal; /* Total time */
int bWithoutRowid; /* True for --without-rowid */
int bReprepare; /* True to reprepare the SQL on each rerun */
+ unsigned int mPrepFlags; /* Flags passed into sqlite3_prepare_v3() */
int bSqlOnly; /* True to print the SQL once only */
int bExplain; /* Print SQL with EXPLAIN prefix */
int bVerify; /* Try to verify that results are correct */
@@ -496,7 +498,7 @@ char *speedtest1_once(const char *zFormat, ...){
if( g.bSqlOnly ){
printSql(zSql);
}else{
- int rc = sqlite3_prepare_v2(g.db, zSql, -1, &pStmt, 0);
+ int rc = sqlite3_prepare_v3(g.db, zSql, -1, 0, &pStmt, 0);
if( rc ){
fatal_error("SQL error: %s\n", sqlite3_errmsg(g.db));
}
@@ -523,7 +525,7 @@ void speedtest1_prepare(const char *zFormat, ...){
}else{
int rc;
if( g.pStmt ) sqlite3_finalize(g.pStmt);
- rc = sqlite3_prepare_v2(g.db, zSql, -1, &g.pStmt, 0);
+ rc = sqlite3_prepare_v3(g.db, zSql, -1, g.mPrepFlags, &g.pStmt, 0);
if( rc ){
fatal_error("SQL error: %s\n", sqlite3_errmsg(g.db));
}
@@ -586,8 +588,16 @@ void speedtest1_run(void){
#if SQLITE_VERSION_NUMBER>=3006001
if( g.bReprepare ){
sqlite3_stmt *pNew;
- sqlite3_prepare_v2(g.db, sqlite3_sql(g.pStmt), -1, &pNew, 0);
- sqlite3_finalize(g.pStmt);
+ if( g.mPrepFlags & SQLITE_PREPARE_PERSISTENT ){
+ char zBuf[1000];
+ strncpy(zBuf, sqlite3_sql(g.pStmt), sizeof(zBuf));
+ zBuf[sizeof(zBuf)-1] = 0;
+ sqlite3_finalize(g.pStmt);
+ sqlite3_prepare_v3(g.db, zBuf, -1, g.mPrepFlags, &pNew, 0);
+ }else{
+ sqlite3_prepare_v2(g.db, sqlite3_sql(g.pStmt), -1, &pNew, 0);
+ sqlite3_finalize(g.pStmt);
+ }
g.pStmt = pNew;
}else
#endif
@@ -2273,6 +2283,8 @@ int main(int argc, char **argv){
if( i>=argc-1 ) fatal_error("missing arguments on %s\n", argv[i]);
g.nRepeat = integerValue(argv[i+1]);
i += 1;
+ }else if( strcmp(z,"persist")==0 ){
+ g.mPrepFlags |= SQLITE_PREPARE_PERSISTENT;
}else if( strcmp(z,"reprepare")==0 ){
g.bReprepare = 1;
#if SQLITE_VERSION_NUMBER>=3006000
diff --git a/tool/speed-check.sh b/tool/speed-check.sh
index 6b0fbeb43a..6d69ea0320 100644
--- a/tool/speed-check.sh
+++ b/tool/speed-check.sh
@@ -143,6 +143,9 @@ while test "$1" != ""; do
SPEEDTEST_OPTS="$SPEEDTEST_OPTS --testset rtree"
CC_OPTS="$CC_OPTS -DSQLITE_ENABLE_RTREE"
;;
+ --persist)
+ SPEEDTEST_OPTS="$SPEEDTEST_OPTS --persist"
+ ;;
--orm)
SPEEDTEST_OPTS="$SPEEDTEST_OPTS --testset orm"
;;
|