1026 lines
33 KiB
C
1026 lines
33 KiB
C
/*
|
|
** This file implements an eponymous, read-only table-valued function
|
|
** (a virtual table) designed to be used for testing. We are not aware
|
|
** of any practical real-world use case for the virtual table.
|
|
**
|
|
** This virtual table originated in the TH3 test suite. It is still used
|
|
** there, but has now been copied into the public SQLite source tree and
|
|
** reused for a variety of testing purpose. The name "vt02" comes from the
|
|
** fact that there are many different testing virtual tables in TH3, of which
|
|
** this one is the second.
|
|
**
|
|
** ## SUBJECT TO CHANGE
|
|
**
|
|
** Because this virtual table is intended for testing, its interface is not
|
|
** guaranteed to be stable across releases. Future releases may contain
|
|
** changes in the vt02 design and interface.
|
|
**
|
|
** ## OVERVIEW
|
|
**
|
|
** The vt02 table-valued function has 10000 rows with 5 data columns.
|
|
** Column X contains all integer values between 0 and 9999 inclusive.
|
|
** Columns A, B, C, and D contain the individual base-10 digits associated
|
|
** with each X value:
|
|
**
|
|
** X A B C D
|
|
** ---- - - - -
|
|
** 0 0 0 0 0
|
|
** 1 0 0 0 1
|
|
** 2 0 0 0 2
|
|
** ...
|
|
** 4998 4 9 9 8
|
|
** 4999 4 9 9 9
|
|
** 5000 5 0 0 0
|
|
** ...
|
|
** 9995 9 9 9 5
|
|
** 9996 9 9 9 6
|
|
** 9997 9 9 9 7
|
|
**
|
|
** The xBestIndex method recognizes a variety of equality constraints
|
|
** and attempts to optimize its output accordingly.
|
|
**
|
|
** x=...
|
|
** a=...
|
|
** a=... AND b=...
|
|
** a=... AND b=... AND c=...
|
|
** a=... AND b=... AND c=... AND d=...
|
|
**
|
|
** Various ORDER BY constraints are also recognized and consumed. The
|
|
** OFFSET constraint is recognized and consumed.
|
|
**
|
|
** ## TABLE-VALUED FUNCTION
|
|
**
|
|
** The vt02 virtual table is eponymous and has two hidden columns, meaning
|
|
** that it can functions a table-valued function. The two hidden columns
|
|
** are "flags" and "logtab", in that order. The "flags" column can be set
|
|
** to an integer where various bits enable or disable behaviors of the
|
|
** virtual table. The "logtab" can set to the name of an ordinary SQLite
|
|
** table into which is written information about each call to xBestIndex.
|
|
**
|
|
** The bits of "flags" are as follows:
|
|
**
|
|
** 0x01 Ignore the aConstraint[].usable flag. This might
|
|
** result in the xBestIndex method incorrectly using
|
|
** unusable entries in the aConstraint[] array, which
|
|
** should result in the SQLite core detecting and
|
|
** reporting that the virtual table is not behaving
|
|
** to spec.
|
|
**
|
|
** 0x02 Do not set the orderByConsumed flag, even if it
|
|
** could be set.
|
|
**
|
|
** 0x04 Do not consume the OFFSET constraint, if there is
|
|
** one. Instead, let the generated byte-code visit
|
|
** and ignore the first few columns of output.
|
|
**
|
|
** 0x08 Use sqlite3_mprintf() to allocate an idxStr string.
|
|
** The string is never used, but allocating it does
|
|
** test the idxStr deallocation logic inside of the
|
|
** SQLite core.
|
|
**
|
|
** 0x10 Cause the xBestIndex method to generate an idxNum
|
|
** that xFilter does not understand, thus causing
|
|
** the OP_VFilter opcode to raise an error.
|
|
**
|
|
** 0x20 Set the omit flag for all equality constraints on
|
|
** columns X, A, B, C, and D that are used to limit
|
|
** the search.
|
|
**
|
|
** 0x40 Add all constraints against X,A,B,C,D to the
|
|
** vector of results sent to xFilter. Only the first
|
|
** few are used, as required by idxNum.
|
|
**
|
|
** Because these flags take effect during xBestIndex, the RHS of the
|
|
** flag= constraint must be accessible. In other words, the RHS of flag=
|
|
** needs to be an integer literal, not another column of a join or a
|
|
** bound parameter.
|
|
**
|
|
** ## LOGGING OUTPUT
|
|
**
|
|
** If the "logtab" columns is set, then each call to the xBestIndex method
|
|
** inserts multiple rows into the table identified by "logtab". These
|
|
** rows collectively show the content of the sqlite3_index_info object and
|
|
** other context associated with the xBestIndex call.
|
|
**
|
|
** If the table named by "logtab" does not previously exist, it is created
|
|
** automatically. The schema for the logtab table is like this:
|
|
**
|
|
** CREATE TEMP TABLE vt02_log(
|
|
** bi INT, -- BestIndex call counter
|
|
** vn TEXT, -- Variable Name
|
|
** ix INT, -- Index or value
|
|
** cn TEXT, -- Column Name
|
|
** op INT, -- Opcode or "DESC" value
|
|
** ux INT, -- "Usable" flag
|
|
** ra BOOLEAN, -- Right-hand side Available.
|
|
** rhs ANY, -- Right-Hand Side value
|
|
** cs TEXT -- Collating Sequence for this constraint
|
|
** );
|
|
**
|
|
** Because logging happens during xBestIindex, the RHS value of "logtab" must
|
|
** be known to xBestIndex, which means it must be a string literal, not a
|
|
** column in a join, or a bound parameter.
|
|
**
|
|
** ## VIRTUAL TABLE SCHEMA
|
|
**
|
|
** CREATE TABLE vt02(
|
|
** x INT, -- integer between 0 and 9999 inclusive
|
|
** a INT, -- The 1000s digit
|
|
** b INT, -- The 100s digit
|
|
** c INT, -- The 10s digit
|
|
** d INT, -- The 1s digit
|
|
** flags INT HIDDEN, -- Option flags
|
|
** logtab TEXT HIDDEN, -- Name of table into which to log xBestIndex
|
|
** );
|
|
**
|
|
** ## COMPILING AND RUNNING
|
|
**
|
|
** This file can also be compiled separately as a loadable extension
|
|
** for SQLite (as long as the -DTH3_VERSION is not defined). To compile as a
|
|
** loadable extension do his:
|
|
**
|
|
** gcc -Wall -g -shared -fPIC -I. -DSQLITE_DEBUG vt02.c -o vt02.so
|
|
**
|
|
** Or on Windows:
|
|
**
|
|
** cl vt02.c -link -dll -out:vt02.dll
|
|
**
|
|
** Then load into the CLI using:
|
|
**
|
|
** .load ./vt02 sqlite3_vt02_init
|
|
**
|
|
** ## IDXNUM SUMMARY
|
|
**
|
|
** The xBestIndex method communicates the query plan to xFilter using
|
|
** the idxNum value, as follows:
|
|
**
|
|
** 0 unconstrained
|
|
** 1 X=argv[0]
|
|
** 2 A=argv[0]
|
|
** 3 A=argv[0], B=argv[1]
|
|
** 4 A=argv[0], B=argv[1], C=argv[2]
|
|
** 5 A=argv[0], B=argv[1], C=argv[2], D=argv[3]
|
|
** 6 A=argv[0], D IN argv[2]
|
|
** 7 A=argv[0], B=argv[2], D IN argv[3]
|
|
** 8 A=argv[0], B=argv[2], C=argv[3], D IN argv[4]
|
|
** 1x increment by 10
|
|
** 2x increment by 100
|
|
** 3x increment by 1000
|
|
** 1xx Use offset provided by argv[N]
|
|
*/
|
|
#ifndef TH3_VERSION
|
|
/* These bits for separate compilation as a loadable extension, only */
|
|
#include "sqlite3ext.h"
|
|
SQLITE_EXTENSION_INIT1
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#endif
|
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
|
|
/* Forward declarations */
|
|
typedef struct vt02_vtab vt02_vtab;
|
|
typedef struct vt02_cur vt02_cur;
|
|
|
|
/*
|
|
** The complete virtual table
|
|
*/
|
|
struct vt02_vtab {
|
|
sqlite3_vtab parent; /* Base clase. Must be first. */
|
|
sqlite3 *db; /* Database connection */
|
|
int busy; /* Currently running xBestIndex */
|
|
};
|
|
|
|
#define VT02_IGNORE_USABLE 0x0001 /* Ignore usable flags */
|
|
#define VT02_NO_SORT_OPT 0x0002 /* Do not do any sorting optimizations */
|
|
#define VT02_NO_OFFSET 0x0004 /* Omit the offset optimization */
|
|
#define VT02_ALLOC_IDXSTR 0x0008 /* Alloate an idxStr */
|
|
#define VT02_BAD_IDXNUM 0x0010 /* Generate an invalid idxNum */
|
|
|
|
/*
|
|
** A cursor
|
|
*/
|
|
struct vt02_cur {
|
|
sqlite3_vtab_cursor parent; /* Base class. Must be first */
|
|
sqlite3_int64 i; /* Current entry */
|
|
sqlite3_int64 iEof; /* Indicate EOF when reaching this value */
|
|
int iIncr; /* Amount by which to increment */
|
|
unsigned int mD; /* Mask of allowed D-column values */
|
|
};
|
|
|
|
/* The xConnect method */
|
|
int vt02Connect(
|
|
sqlite3 *db, /* The database connection */
|
|
void *pAux, /* Pointer to an alternative schema */
|
|
int argc, /* Number of arguments */
|
|
const char *const*argv, /* Text of the arguments */
|
|
sqlite3_vtab **ppVTab, /* Write the new vtab here */
|
|
char **pzErr /* Error message written here */
|
|
){
|
|
vt02_vtab *pVtab;
|
|
int rc;
|
|
const char *zSchema = (const char*)pAux;
|
|
static const char zDefaultSchema[] =
|
|
"CREATE TABLE x(x INT, a INT, b INT, c INT, d INT,"
|
|
" flags INT HIDDEN, logtab TEXT HIDDEN);";
|
|
#define VT02_COL_X 0
|
|
#define VT02_COL_A 1
|
|
#define VT02_COL_B 2
|
|
#define VT02_COL_C 3
|
|
#define VT02_COL_D 4
|
|
#define VT02_COL_FLAGS 5
|
|
#define VT02_COL_LOGTAB 6
|
|
#define VT02_COL_NONE 7
|
|
|
|
pVtab = sqlite3_malloc( sizeof(*pVtab) );
|
|
if( pVtab==0 ){
|
|
*pzErr = sqlite3_mprintf("out of memory");
|
|
return SQLITE_NOMEM;
|
|
}
|
|
memset(pVtab, 0, sizeof(*pVtab));
|
|
pVtab->db = db;
|
|
rc = sqlite3_declare_vtab(db, zSchema ? zSchema : zDefaultSchema);
|
|
if( rc ){
|
|
sqlite3_free(pVtab);
|
|
}else{
|
|
*ppVTab = &pVtab->parent;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/* the xDisconnect method
|
|
*/
|
|
int vt02Disconnect(sqlite3_vtab *pVTab){
|
|
sqlite3_free(pVTab);
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/* Put an error message into the zErrMsg string of the virtual table.
|
|
*/
|
|
static void vt02ErrMsg(sqlite3_vtab *pVtab, const char *zFormat, ...){
|
|
va_list ap;
|
|
sqlite3_free(pVtab->zErrMsg);
|
|
va_start(ap, zFormat);
|
|
pVtab->zErrMsg = sqlite3_vmprintf(zFormat, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
|
|
/* Open a cursor for scanning
|
|
*/
|
|
static int vt02Open(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
|
|
vt02_cur *pCur;
|
|
pCur = sqlite3_malloc( sizeof(*pCur) );
|
|
if( pCur==0 ){
|
|
vt02ErrMsg(pVTab, "out of memory");
|
|
return SQLITE_NOMEM;
|
|
}
|
|
*ppCursor = &pCur->parent;
|
|
pCur->i = -1;
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/* Close a cursor
|
|
*/
|
|
static int vt02Close(sqlite3_vtab_cursor *pCursor){
|
|
vt02_cur *pCur = (vt02_cur*)pCursor;
|
|
sqlite3_free(pCur);
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/* Return TRUE if we are at the end of the BVS and there are
|
|
** no more entries.
|
|
*/
|
|
static int vt02Eof(sqlite3_vtab_cursor *pCursor){
|
|
vt02_cur *pCur = (vt02_cur*)pCursor;
|
|
return pCur->i<0 || pCur->i>=pCur->iEof;
|
|
}
|
|
|
|
/* Advance the cursor to the next row in the table
|
|
*/
|
|
static int vt02Next(sqlite3_vtab_cursor *pCursor){
|
|
vt02_cur *pCur = (vt02_cur*)pCursor;
|
|
do{
|
|
pCur->i += pCur->iIncr;
|
|
if( pCur->i<0 ) pCur->i = pCur->iEof;
|
|
}while( (pCur->mD & (1<<(pCur->i%10)))==0 && pCur->i<pCur->iEof );
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/* Rewind a cursor back to the beginning of its scan.
|
|
**
|
|
** Scanning is always increasing.
|
|
**
|
|
** idxNum
|
|
** 0 unconstrained
|
|
** 1 X=argv[0]
|
|
** 2 A=argv[0]
|
|
** 3 A=argv[0], B=argv[1]
|
|
** 4 A=argv[0], B=argv[1], C=argv[2]
|
|
** 5 A=argv[0], B=argv[1], C=argv[2], D=argv[3]
|
|
** 6 A=argv[0], D IN argv[2]
|
|
** 7 A=argv[0], B=argv[2], D IN argv[3]
|
|
** 8 A=argv[0], B=argv[2], C=argv[3], D IN argv[4]
|
|
** 1x increment by 10
|
|
** 2x increment by 100
|
|
** 3x increment by 1000
|
|
** 1xx Use offset provided by argv[N]
|
|
*/
|
|
static int vt02Filter(
|
|
sqlite3_vtab_cursor *pCursor, /* The cursor to rewind */
|
|
int idxNum, /* Search strategy */
|
|
const char *idxStr, /* Not used */
|
|
int argc, /* Not used */
|
|
sqlite3_value **argv /* Not used */
|
|
){
|
|
vt02_cur *pCur = (vt02_cur*)pCursor; /* The vt02 cursor */
|
|
int bUseOffset = 0; /* True to use OFFSET value */
|
|
int iArg = 0; /* argv[] values used so far */
|
|
int iOrigIdxNum = idxNum; /* Original value for idxNum */
|
|
|
|
pCur->iIncr = 1;
|
|
pCur->mD = 0x3ff;
|
|
if( idxNum>=100 ){
|
|
bUseOffset = 1;
|
|
idxNum -= 100;
|
|
}
|
|
if( idxNum<0 || idxNum>38 ) goto vt02_bad_idxnum;
|
|
while( idxNum>=10 ){
|
|
pCur->iIncr *= 10;
|
|
idxNum -= 10;
|
|
}
|
|
if( idxNum==0 ){
|
|
pCur->i = 0;
|
|
pCur->iEof = 10000;
|
|
}else if( idxNum==1 ){
|
|
pCur->i = sqlite3_value_int64(argv[0]);
|
|
if( pCur->i<0 ) pCur->i = -1;
|
|
if( pCur->i>9999 ) pCur->i = 10000;
|
|
pCur->iEof = pCur->i+1;
|
|
if( pCur->i<0 || pCur->i>9999 ) pCur->i = pCur->iEof;
|
|
}else if( idxNum>=2 && idxNum<=5 ){
|
|
int i, e, m;
|
|
e = idxNum - 2;
|
|
assert( e<=argc-1 );
|
|
pCur->i = 0;
|
|
for(m=1000, i=0; i<=e; i++, m /= 10){
|
|
sqlite3_int64 v = sqlite3_value_int64(argv[iArg++]);
|
|
if( v<0 ) v = 0;
|
|
if( v>9 ) v = 9;
|
|
pCur->i += m*v;
|
|
pCur->iEof = pCur->i+m;
|
|
}
|
|
}else if( idxNum>=6 && idxNum<=8 ){
|
|
int i, e, m, rc;
|
|
sqlite3_value *pIn, *pVal;
|
|
e = idxNum - 6;
|
|
assert( e<=argc-2 );
|
|
pCur->i = 0;
|
|
for(m=1000, i=0; i<=e; i++, m /= 10){
|
|
sqlite3_int64 v;
|
|
pVal = 0;
|
|
if( sqlite3_vtab_in_first(0, &pVal)!=SQLITE_MISUSE
|
|
|| sqlite3_vtab_in_first(argv[iArg], &pVal)!=SQLITE_MISUSE
|
|
){
|
|
vt02ErrMsg(pCursor->pVtab,
|
|
"unexpected success from sqlite3_vtab_in_first()");
|
|
return SQLITE_ERROR;
|
|
}
|
|
v = sqlite3_value_int64(argv[iArg++]);
|
|
if( v<0 ) v = 0;
|
|
if( v>9 ) v = 9;
|
|
pCur->i += m*v;
|
|
pCur->iEof = pCur->i+m;
|
|
}
|
|
pCur->mD = 0;
|
|
pIn = argv[iArg++];
|
|
assert( sqlite3_value_type(pIn)==SQLITE_NULL );
|
|
for( rc = sqlite3_vtab_in_first(pIn, &pVal);
|
|
rc==SQLITE_OK && pVal!=0;
|
|
rc = sqlite3_vtab_in_next(pIn, &pVal)
|
|
){
|
|
int eType = sqlite3_value_numeric_type(pVal);
|
|
if( eType==SQLITE_FLOAT ){
|
|
double r = sqlite3_value_double(pVal);
|
|
if( r<0.0 || r>9.0 || r!=(int)r ) continue;
|
|
}else if( eType!=SQLITE_INTEGER ){
|
|
continue;
|
|
}
|
|
i = sqlite3_value_int(pVal);
|
|
if( i<0 || i>9 ) continue;
|
|
pCur->mD |= 1<<i;
|
|
}
|
|
if( rc!=SQLITE_OK && rc!=SQLITE_DONE ){
|
|
vt02ErrMsg(pCursor->pVtab, "Error from sqlite3_vtab_in_first/next()");
|
|
return rc;
|
|
}
|
|
}else{
|
|
goto vt02_bad_idxnum;
|
|
}
|
|
if( bUseOffset ){
|
|
int nSkip = sqlite3_value_int(argv[iArg]);
|
|
while( nSkip-- > 0 ) vt02Next(pCursor);
|
|
}
|
|
return SQLITE_OK;
|
|
|
|
vt02_bad_idxnum:
|
|
vt02ErrMsg(pCursor->pVtab, "invalid idxNum for vt02: %d", iOrigIdxNum);
|
|
return SQLITE_ERROR;
|
|
}
|
|
|
|
/* Return the Nth column of the current row.
|
|
*/
|
|
static int vt02Column(
|
|
sqlite3_vtab_cursor *pCursor,
|
|
sqlite3_context *context,
|
|
int N
|
|
){
|
|
vt02_cur *pCur = (vt02_cur*)pCursor;
|
|
int v = pCur->i;
|
|
if( N==VT02_COL_X ){
|
|
sqlite3_result_int(context, v);
|
|
}else if( N>=VT02_COL_A && N<=VT02_COL_D ){
|
|
static const int iDivisor[] = { 1, 1000, 100, 10, 1 };
|
|
v = (v/iDivisor[N])%10;
|
|
sqlite3_result_int(context, v);
|
|
}
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/* Return the rowid of the current row
|
|
*/
|
|
static int vt02Rowid(sqlite3_vtab_cursor *pCursor, sqlite3_int64 *pRowid){
|
|
vt02_cur *pCur = (vt02_cur*)pCursor;
|
|
*pRowid = pCur->i+1;
|
|
return SQLITE_OK;
|
|
}
|
|
|
|
/*************************************************************************
|
|
** Logging Subsystem
|
|
**
|
|
** The sqlite3BestIndexLog() routine implements a logging system for
|
|
** xBestIndex calls. This code is portable to any virtual table.
|
|
**
|
|
** sqlite3BestIndexLog() is the main routine, sqlite3RunSql() is a
|
|
** helper routine used for running various SQL statements as part of
|
|
** creating the log.
|
|
**
|
|
** These two routines should be portable to other virtual tables. Simply
|
|
** extract this code and call sqlite3BestIndexLog() near the end of the
|
|
** xBestIndex method in cases where logging is desired.
|
|
*/
|
|
/*
|
|
** Run SQL on behalf of sqlite3BestIndexLog.
|
|
**
|
|
** Construct the SQL using the zFormat string and subsequent arguments.
|
|
** Or if zFormat is NULL, take the SQL as the first argument after the
|
|
** zFormat. In either case, the dynamically allocated SQL string is
|
|
** freed after it has been run. If something goes wrong with the SQL,
|
|
** then an error is left in pVTab->zErrMsg.
|
|
*/
|
|
static void sqlite3RunSql(
|
|
sqlite3 *db, /* Run the SQL on this database connection */
|
|
sqlite3_vtab *pVTab, /* Report errors to this virtual table */
|
|
const char *zFormat, /* Format string for SQL, or NULL */
|
|
... /* Arguments, according to the format string */
|
|
){
|
|
char *zSql;
|
|
|
|
va_list ap;
|
|
va_start(ap, zFormat);
|
|
if( zFormat==0 ){
|
|
zSql = va_arg(ap, char*);
|
|
}else{
|
|
zSql = sqlite3_vmprintf(zFormat, ap);
|
|
}
|
|
va_end(ap);
|
|
if( zSql ){
|
|
char *zErrMsg = 0;
|
|
(void)sqlite3_exec(db, zSql, 0, 0, &zErrMsg);
|
|
if( zErrMsg ){
|
|
if( pVTab->zErrMsg==0 ){
|
|
pVTab->zErrMsg = sqlite3_mprintf("%s in [%s]", zErrMsg, zSql);
|
|
}
|
|
sqlite3_free(zErrMsg);
|
|
}
|
|
sqlite3_free(zSql);
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Record information about each xBestIndex method call in a separate
|
|
** table:
|
|
**
|
|
** CREATE TEMP TABLE [log-table-name] (
|
|
** bi INT, -- BestIndex call number
|
|
** vn TEXT, -- Variable Name
|
|
** ix INT, -- Index or value
|
|
** cn TEXT, -- Column Name
|
|
** op INT, -- Opcode or argvIndex
|
|
** ux INT, -- "usable" or "omit" flag
|
|
** rx BOOLEAN, -- True if has a RHS value
|
|
** rhs ANY, -- The RHS value
|
|
** cs TEXT, -- Collating Sequence
|
|
** inop BOOLEAN -- True if this is a batchable IN operator
|
|
** );
|
|
**
|
|
** If an error occurs, leave an error message in pVTab->zErrMsg.
|
|
*/
|
|
static void sqlite3BestIndexLog(
|
|
sqlite3_index_info *pInfo, /* The sqlite3_index_info object */
|
|
const char *zLogTab, /* Log into this table */
|
|
sqlite3 *db, /* Database connection containing zLogTab */
|
|
const char **azColname, /* Names of columns in the virtual table */
|
|
sqlite3_vtab *pVTab /* Record errors into this object */
|
|
){
|
|
int i, rc;
|
|
sqlite3_str *pStr;
|
|
int iBI;
|
|
|
|
if( sqlite3_table_column_metadata(db,0,zLogTab,0,0,0,0,0,0) ){
|
|
/* The log table does not previously exist. Create it. */
|
|
sqlite3RunSql(db,pVTab,
|
|
"CREATE TABLE IF NOT EXISTS temp.\"%w\"(\n"
|
|
" bi INT, -- BestIndex call number\n"
|
|
" vn TEXT, -- Variable Name\n"
|
|
" ix INT, -- Index or value\n"
|
|
" cn TEXT, -- Column Name\n"
|
|
" op INT, -- Opcode or argvIndex\n"
|
|
" ux INT, -- usable for omit flag\n"
|
|
" rx BOOLEAN, -- Right-hand side value is available\n"
|
|
" rhs ANY, -- RHS value\n"
|
|
" cs TEXT, -- Collating Sequence\n"
|
|
" inop BOOLEAN -- IN operator capable of batch reads\n"
|
|
");", zLogTab
|
|
);
|
|
iBI = 1;
|
|
}else{
|
|
/* The log table does already exist. We assume that it has the
|
|
** correct schema and proceed to find the largest prior "bi" value.
|
|
** If the schema is wrong, errors might result. The code is able
|
|
** to deal with this. */
|
|
sqlite3_stmt *pStmt;
|
|
char *zSql;
|
|
zSql = sqlite3_mprintf("SELECT max(bi) FROM temp.\"%w\"",zLogTab);
|
|
if( zSql==0 ){
|
|
sqlite3_free(pVTab->zErrMsg);
|
|
pVTab->zErrMsg = sqlite3_mprintf("out of memory");
|
|
return;
|
|
}
|
|
rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
|
|
sqlite3_free(zSql);
|
|
if( rc ){
|
|
sqlite3_free(pVTab->zErrMsg);
|
|
pVTab->zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
|
|
iBI = 0;
|
|
}else if( sqlite3_step(pStmt)==SQLITE_ROW ){
|
|
iBI = sqlite3_column_int(pStmt, 0)+1;
|
|
}else{
|
|
iBI = 1;
|
|
}
|
|
sqlite3_finalize(pStmt);
|
|
}
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix) VALUES(%d,'nConstraint',%d)",
|
|
zLogTab, iBI, pInfo->nConstraint
|
|
);
|
|
for(i=0; i<pInfo->nConstraint; i++){
|
|
sqlite3_value *pVal;
|
|
char *zSql;
|
|
int iCol = pInfo->aConstraint[i].iColumn;
|
|
int op = pInfo->aConstraint[i].op;
|
|
const char *zCol;
|
|
if( op==SQLITE_INDEX_CONSTRAINT_LIMIT
|
|
|| op==SQLITE_INDEX_CONSTRAINT_OFFSET
|
|
){
|
|
zCol = "";
|
|
}else if( iCol<0 ){
|
|
zCol = "rowid";
|
|
}else{
|
|
zCol = azColname[iCol];
|
|
}
|
|
pStr = sqlite3_str_new(0);
|
|
sqlite3_str_appendf(pStr,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix,cn,op,ux,rx,rhs,cs,inop)"
|
|
"VALUES(%d,'aConstraint',%d,%Q,%d,%d",
|
|
zLogTab, iBI,
|
|
i,
|
|
zCol,
|
|
op,
|
|
pInfo->aConstraint[i].usable);
|
|
pVal = 0;
|
|
rc = sqlite3_vtab_rhs_value(pInfo, i, &pVal);
|
|
assert( pVal!=0 || rc!=SQLITE_OK );
|
|
if( rc==SQLITE_OK ){
|
|
sqlite3_str_appendf(pStr,",1,?1");
|
|
}else{
|
|
sqlite3_str_appendf(pStr,",0,NULL");
|
|
}
|
|
sqlite3_str_appendf(pStr,",%Q,%d)",
|
|
sqlite3_vtab_collation(pInfo,i),
|
|
sqlite3_vtab_in(pInfo,i,-1));
|
|
zSql = sqlite3_str_finish(pStr);
|
|
if( zSql==0 ){
|
|
if( pVTab->zErrMsg==0 ) pVTab->zErrMsg = sqlite3_mprintf("out of memory");
|
|
}else{
|
|
sqlite3_stmt *pStmt = 0;
|
|
rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
|
|
if( rc ){
|
|
if( pVTab->zErrMsg==0 ){
|
|
pVTab->zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
|
|
}
|
|
}else{
|
|
if( pVal ) sqlite3_bind_value(pStmt, 1, pVal);
|
|
sqlite3_step(pStmt);
|
|
rc = sqlite3_reset(pStmt);
|
|
if( rc && pVTab->zErrMsg==0 ){
|
|
pVTab->zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(db));
|
|
}
|
|
}
|
|
sqlite3_finalize(pStmt);
|
|
sqlite3_free(zSql);
|
|
}
|
|
}
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix) VALUES(%d,'nOrderBy',%d)",
|
|
zLogTab, iBI, pInfo->nOrderBy
|
|
);
|
|
for(i=0; i<pInfo->nOrderBy; i++){
|
|
int iCol = pInfo->aOrderBy[i].iColumn;
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix,cn,op)VALUES(%d,'aOrderBy',%d,%Q,%d)",
|
|
zLogTab, iBI,
|
|
i,
|
|
iCol>=0 ? azColname[iCol] : "rowid",
|
|
pInfo->aOrderBy[i].desc
|
|
);
|
|
}
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix) VALUES(%d,'sqlite3_vtab_distinct',%d)",
|
|
zLogTab, iBI, sqlite3_vtab_distinct(pInfo)
|
|
);
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix) VALUES(%d,'colUsed',%lld)",
|
|
zLogTab, iBI, pInfo->colUsed
|
|
);
|
|
for(i=0; i<pInfo->nConstraint; i++){
|
|
int iCol = pInfo->aConstraint[i].iColumn;
|
|
int op = pInfo->aConstraint[i].op;
|
|
const char *zCol;
|
|
if( op==SQLITE_INDEX_CONSTRAINT_LIMIT
|
|
|| op==SQLITE_INDEX_CONSTRAINT_OFFSET
|
|
){
|
|
zCol = "";
|
|
}else if( iCol<0 ){
|
|
zCol = "rowid";
|
|
}else{
|
|
zCol = azColname[iCol];
|
|
}
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix,cn,op,ux)"
|
|
"VALUES(%d,'aConstraintUsage',%d,%Q,%d,%d)",
|
|
zLogTab, iBI,
|
|
i,
|
|
zCol,
|
|
pInfo->aConstraintUsage[i].argvIndex,
|
|
pInfo->aConstraintUsage[i].omit
|
|
);
|
|
}
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix)VALUES(%d,'idxNum',%d)",
|
|
zLogTab, iBI, pInfo->idxNum
|
|
);
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix)VALUES(%d,'estimatedCost',%f)",
|
|
zLogTab, iBI, pInfo->estimatedCost
|
|
);
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix)VALUES(%d,'estimatedRows',%lld)",
|
|
zLogTab, iBI, pInfo->estimatedRows
|
|
);
|
|
if( pInfo->idxStr ){
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix)VALUES(%d,'idxStr',%Q)",
|
|
zLogTab, iBI, pInfo->idxStr
|
|
);
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix)VALUES(%d,'needToFreeIdxStr',%d)",
|
|
zLogTab, iBI, pInfo->needToFreeIdxStr
|
|
);
|
|
}
|
|
if( pInfo->nOrderBy ){
|
|
sqlite3RunSql(db,pVTab,
|
|
"INSERT INTO temp.\"%w\"(bi,vn,ix)VALUES(%d,'orderByConsumed',%d)",
|
|
zLogTab, iBI, pInfo->orderByConsumed
|
|
);
|
|
}
|
|
}
|
|
/*
|
|
** End of Logging Subsystem
|
|
*****************************************************************************/
|
|
|
|
|
|
/* Find an estimated cost of running a query against vt02.
|
|
*/
|
|
static int vt02BestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
|
|
int i; /* Loop counter */
|
|
int isEq[5]; /* Equality constraints on X, A, B, C, and D */
|
|
int isUsed[5]; /* Other non-== cosntraints X, A, B, C, and D */
|
|
int argvIndex = 0; /* Next available argv[] slot */
|
|
int iOffset = -1; /* Constraint for OFFSET */
|
|
void *pX = 0; /* idxStr value */
|
|
int flags = 0; /* RHS value for flags= */
|
|
const char *zLogTab = 0; /* RHS value for logtab= */
|
|
int iFlagTerm = -1; /* Constraint term for flags= */
|
|
int iLogTerm = -1; /* Constraint term for logtab= */
|
|
int iIn = -1; /* Index of the IN constraint */
|
|
vt02_vtab *pSelf; /* This virtual table */
|
|
|
|
pSelf = (vt02_vtab*)pVTab;
|
|
if( pSelf->busy ){
|
|
vt02ErrMsg(pVTab, "recursive use of vt02 prohibited");
|
|
return SQLITE_CONSTRAINT;
|
|
}
|
|
pSelf->busy++;
|
|
|
|
|
|
/* Do an initial scan for flags=N and logtab=TAB constraints with
|
|
** usable RHS values */
|
|
for(i=0; i<pInfo->nConstraint; i++){
|
|
sqlite3_value *pVal;
|
|
if( !pInfo->aConstraint[i].usable ) continue;
|
|
if( pInfo->aConstraint[i].op!=SQLITE_INDEX_CONSTRAINT_EQ ) continue;
|
|
switch( pInfo->aConstraint[i].iColumn ){
|
|
case VT02_COL_FLAGS:
|
|
if( sqlite3_vtab_rhs_value(pInfo, i, &pVal)==SQLITE_OK
|
|
&& sqlite3_value_type(pVal)==SQLITE_INTEGER
|
|
){
|
|
flags = sqlite3_value_int(pVal);
|
|
}
|
|
iFlagTerm = i;
|
|
break;
|
|
case VT02_COL_LOGTAB:
|
|
if( sqlite3_vtab_rhs_value(pInfo, i, &pVal)==SQLITE_OK
|
|
&& sqlite3_value_type(pVal)==SQLITE_TEXT
|
|
){
|
|
zLogTab = (const char*)sqlite3_value_text(pVal);
|
|
}
|
|
iLogTerm = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Do a second scan to actually analyze the index information */
|
|
memset(isEq, 0xff, sizeof(isEq));
|
|
memset(isUsed, 0xff, sizeof(isUsed));
|
|
for(i=0; i<pInfo->nConstraint; i++){
|
|
int j = pInfo->aConstraint[i].iColumn;
|
|
if( j>=VT02_COL_FLAGS ) continue;
|
|
if( pInfo->aConstraint[i].usable==0
|
|
&& (flags & VT02_IGNORE_USABLE)==0 ) continue;
|
|
if( j<0 ) j = VT02_COL_X;
|
|
switch( pInfo->aConstraint[i].op ){
|
|
case SQLITE_INDEX_CONSTRAINT_FUNCTION:
|
|
case SQLITE_INDEX_CONSTRAINT_EQ:
|
|
isEq[j] = i;
|
|
break;
|
|
case SQLITE_INDEX_CONSTRAINT_LT:
|
|
case SQLITE_INDEX_CONSTRAINT_LE:
|
|
case SQLITE_INDEX_CONSTRAINT_GT:
|
|
case SQLITE_INDEX_CONSTRAINT_GE:
|
|
isUsed[j] = i;
|
|
break;
|
|
case SQLITE_INDEX_CONSTRAINT_OFFSET:
|
|
iOffset = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Use the analysis to find an appropriate query plan */
|
|
if( isEq[0]>=0 ){
|
|
/* A constraint of X= takes priority */
|
|
pInfo->estimatedCost = 1;
|
|
pInfo->aConstraintUsage[isEq[0]].argvIndex = ++argvIndex;
|
|
if( flags & 0x20 ) pInfo->aConstraintUsage[isEq[0]].omit = 1;
|
|
pInfo->idxNum = 1;
|
|
}else if( isEq[1]<0 ){
|
|
/* If there is no X= nor A= then we have to do a full scan */
|
|
pInfo->idxNum = 0;
|
|
pInfo->estimatedCost = 10000;
|
|
}else{
|
|
int v = 1000;
|
|
pInfo->aConstraintUsage[isEq[1]].argvIndex = ++argvIndex;
|
|
if( flags & 0x20 ) pInfo->aConstraintUsage[isEq[1]].omit = 1;
|
|
for(i=2; i<=4 && isEq[i]>=0; i++){
|
|
if( i==4 && sqlite3_vtab_in(pInfo, isEq[4], 0) ) break;
|
|
pInfo->aConstraintUsage[isEq[i]].argvIndex = ++argvIndex;
|
|
if( flags & 0x20 ) pInfo->aConstraintUsage[isEq[i]].omit = 1;
|
|
v /= 10;
|
|
}
|
|
pInfo->idxNum = i;
|
|
if( isEq[4]>=0 && sqlite3_vtab_in(pInfo,isEq[4],1) ){
|
|
iIn = isEq[4];
|
|
pInfo->aConstraintUsage[iIn].argvIndex = ++argvIndex;
|
|
if( flags & 0x20 ) pInfo->aConstraintUsage[iIn].omit = 1;
|
|
v /= 5;
|
|
i++;
|
|
pInfo->idxNum += 4;
|
|
}
|
|
pInfo->estimatedCost = v;
|
|
}
|
|
pInfo->estimatedRows = (sqlite3_int64)pInfo->estimatedCost;
|
|
|
|
/* Attempt to consume the ORDER BY clause. Except, always leave
|
|
** orderByConsumed set to 0 for vt02_no_sort_opt. In this way,
|
|
** we can compare vt02 and vt02_no_sort_opt to ensure they get
|
|
** the same answer.
|
|
*/
|
|
if( pInfo->nOrderBy>0 && (flags & VT02_NO_SORT_OPT)==0 ){
|
|
if( pInfo->idxNum==1 ){
|
|
/* There will only be one row of output. So it is always sorted. */
|
|
pInfo->orderByConsumed = 1;
|
|
}else
|
|
if( pInfo->aOrderBy[0].iColumn<=0
|
|
&& pInfo->aOrderBy[0].desc==0
|
|
){
|
|
/* First column of order by is X ascending */
|
|
pInfo->orderByConsumed = 1;
|
|
}else
|
|
if( sqlite3_vtab_distinct(pInfo)>=1 ){
|
|
unsigned int x = 0;
|
|
for(i=0; i<pInfo->nOrderBy; i++){
|
|
int iCol = pInfo->aOrderBy[i].iColumn;
|
|
if( iCol<0 ) iCol = 0;
|
|
x |= 1<<iCol;
|
|
}
|
|
if( sqlite3_vtab_distinct(pInfo)==2 ){
|
|
if( x==0x02 ){
|
|
/* DISTINCT A */
|
|
pInfo->idxNum += 30;
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x==0x06 ){
|
|
/* DISTINCT A,B */
|
|
pInfo->idxNum += 20;
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x==0x0e ){
|
|
/* DISTINCT A,B,C */
|
|
pInfo->idxNum += 10;
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x & 0x01 ){
|
|
/* DISTINCT X */
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x==0x1e ){
|
|
/* DISTINCT A,B,C,D */
|
|
pInfo->orderByConsumed = 1;
|
|
}
|
|
}else{
|
|
if( x==0x02 ){
|
|
/* GROUP BY A */
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x==0x06 ){
|
|
/* GROUP BY A,B */
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x==0x0e ){
|
|
/* GROUP BY A,B,C */
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x & 0x01 ){
|
|
/* GROUP BY X */
|
|
pInfo->orderByConsumed = 1;
|
|
}else if( x==0x1e ){
|
|
/* GROUP BY A,B,C,D */
|
|
pInfo->orderByConsumed = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( flags & VT02_ALLOC_IDXSTR ){
|
|
pInfo->idxStr = sqlite3_mprintf("test");
|
|
pInfo->needToFreeIdxStr = 1;
|
|
}
|
|
if( flags & VT02_BAD_IDXNUM ){
|
|
pInfo->idxNum += 1000;
|
|
}
|
|
|
|
if( iOffset>=0 ){
|
|
pInfo->aConstraintUsage[iOffset].argvIndex = ++argvIndex;
|
|
if( (flags & VT02_NO_OFFSET)==0
|
|
&& (pInfo->nOrderBy==0 || pInfo->orderByConsumed)
|
|
){
|
|
pInfo->aConstraintUsage[iOffset].omit = 1;
|
|
pInfo->idxNum += 100;
|
|
}
|
|
}
|
|
|
|
|
|
/* Always omit flags= and logtab= constraints to prevent them from
|
|
** interfering with the bytecode. Put them at the end of the argv[]
|
|
** array to keep them out of the way.
|
|
*/
|
|
if( iFlagTerm>=0 ){
|
|
pInfo->aConstraintUsage[iFlagTerm].omit = 1;
|
|
pInfo->aConstraintUsage[iFlagTerm].argvIndex = ++argvIndex;
|
|
}
|
|
if( iLogTerm>=0 ){
|
|
pInfo->aConstraintUsage[iLogTerm].omit = 1;
|
|
pInfo->aConstraintUsage[iLogTerm].argvIndex = ++argvIndex;
|
|
}
|
|
|
|
/* The 0x40 flag means add all usable constraints to the output set */
|
|
if( flags & 0x40 ){
|
|
for(i=0; i<pInfo->nConstraint; i++){
|
|
if( pInfo->aConstraint[i].usable
|
|
&& pInfo->aConstraintUsage[i].argvIndex==0
|
|
){
|
|
pInfo->aConstraintUsage[i].argvIndex = ++argvIndex;
|
|
if( flags & 0x20 ) pInfo->aConstraintUsage[i].omit = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* Generate the log if requested */
|
|
if( zLogTab ){
|
|
static const char *azColname[] = {
|
|
"x", "a", "b", "c", "d", "flags", "logtab"
|
|
};
|
|
sqlite3 *db = ((vt02_vtab*)pVTab)->db;
|
|
sqlite3BestIndexLog(pInfo, zLogTab, db, azColname, pVTab);
|
|
}
|
|
pSelf->busy--;
|
|
|
|
/* Try to do a memory allocation solely for the purpose of causing
|
|
** an error under OOM testing loops */
|
|
pX = sqlite3_malloc(800);
|
|
if( pX==0 ) return SQLITE_NOMEM;
|
|
sqlite3_free(pX);
|
|
|
|
return pVTab->zErrMsg!=0 ? SQLITE_ERROR : SQLITE_OK;
|
|
}
|
|
|
|
/* This is the sqlite3_module definition for the the virtual table defined
|
|
** by this include file.
|
|
*/
|
|
const sqlite3_module vt02Module = {
|
|
/* iVersion */ 2,
|
|
/* xCreate */ 0, /* This is an eponymous table */
|
|
/* xConnect */ vt02Connect,
|
|
/* xBestIndex */ vt02BestIndex,
|
|
/* xDisconnect */ vt02Disconnect,
|
|
/* xDestroy */ vt02Disconnect,
|
|
/* xOpen */ vt02Open,
|
|
/* xClose */ vt02Close,
|
|
/* xFilter */ vt02Filter,
|
|
/* xNext */ vt02Next,
|
|
/* xEof */ vt02Eof,
|
|
/* xColumn */ vt02Column,
|
|
/* xRowid */ vt02Rowid,
|
|
/* xUpdate */ 0,
|
|
/* xBegin */ 0,
|
|
/* xSync */ 0,
|
|
/* xCommit */ 0,
|
|
/* xRollback */ 0,
|
|
/* xFindFunction */ 0,
|
|
/* xRename */ 0,
|
|
/* xSavepoint */ 0,
|
|
/* xRelease */ 0,
|
|
/* xRollbackTo */ 0
|
|
};
|
|
|
|
static void vt02CoreInit(sqlite3 *db){
|
|
static const char zPkXSchema[] =
|
|
"CREATE TABLE x(x INT NOT NULL PRIMARY KEY, a INT, b INT, c INT, d INT,"
|
|
" flags INT HIDDEN, logtab TEXT HIDDEN);";
|
|
static const char zPkABCDSchema[] =
|
|
"CREATE TABLE x(x INT, a INT NOT NULL, b INT NOT NULL, c INT NOT NULL, "
|
|
"d INT NOT NULL, flags INT HIDDEN, logtab TEXT HIDDEN, "
|
|
"PRIMARY KEY(a,b,c,d));";
|
|
sqlite3_create_module(db, "vt02", &vt02Module, 0);
|
|
sqlite3_create_module(db, "vt02pkx", &vt02Module, (void*)zPkXSchema);
|
|
sqlite3_create_module(db, "vt02pkabcd", &vt02Module, (void*)zPkABCDSchema);
|
|
}
|
|
|
|
#else
|
|
# define vt02CoreInit(db)
|
|
#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
|
|
|
|
#ifdef TH3_VERSION
|
|
static void vt02_init(th3state *p, int iDb, char *zArg){
|
|
vt02CoreInit(th3dbPointer(p, iDb));
|
|
}
|
|
#else
|
|
#ifdef _WIN32
|
|
__declspec(dllexport)
|
|
#endif
|
|
int sqlite3_vt02_init(
|
|
sqlite3 *db,
|
|
char **pzErrMsg,
|
|
const sqlite3_api_routines *pApi
|
|
){
|
|
SQLITE_EXTENSION_INIT2(pApi);
|
|
vt02CoreInit(db);
|
|
return SQLITE_OK;
|
|
}
|
|
#endif /* TH3_VERSION */
|