/*
** 2006 June 10
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
** Code for testing the virtual table interfaces. This code
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
** $Id: test8.c,v 1.16 2006/06/14 10:55:53 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
#include "os.h"
#include <stdlib.h>
#include <string.h>
typedef struct echo_vtab echo_vtab;
typedef struct echo_cursor echo_cursor;
/*
** An echo virtual-table object
**
** If it is not NULL, the aHasIndex array is allocated so that it has
** the same number of entries as there are columns in the underlying
** real table.
*/
struct echo_vtab {
sqlite3_vtab base;
Tcl_Interp *interp;
sqlite3 *db;
char *zTableName; /* Name of the real table */
int nCol; /* Number of columns in the real table */
int *aIndex; /* Array of size nCol. True if column has an index */
char **aCol; /* Array of size nCol. Column names */
};
/* An echo cursor object */
struct echo_cursor {
sqlite3_vtab_cursor base;
sqlite3_stmt *pStmt;
int errcode; /* Error code */
};
static int getColumnNames(
sqlite3 *db,
const char *zTab,
char ***paCol,
int *pnCol
){
char **aCol = 0;
char zBuf[1024];
sqlite3_stmt *pStmt = 0;
int rc = SQLITE_OK;
int nCol;
sprintf(zBuf, "SELECT * FROM %s", zTab);
rc = sqlite3_prepare(db, zBuf, -1, &pStmt, 0);
if( rc==SQLITE_OK ){
int ii;
nCol = sqlite3_column_count(pStmt);
aCol = sqliteMalloc(sizeof(char *) * nCol);
if( !aCol ){
rc = SQLITE_NOMEM;
goto fail;
}
for(ii=0; ii<nCol; ii++){
aCol[ii] = sqlite3StrDup(sqlite3_column_name(pStmt, ii));
if( !aCol[ii] ){
rc = SQLITE_NOMEM;
goto fail;
}
}
}
*paCol = aCol;
*pnCol = nCol;
fail:
sqlite3_finalize(pStmt);
if( rc!=SQLITE_OK && aCol ){
int ii;
for(ii=0; ii<nCol; ii++){
sqliteFree(aCol[ii]);
}
sqliteFree(aCol);
}
return rc;
}
static int getIndexArray(sqlite3 *db, const char *zTab, int **paIndex){
char zBuf[1024];
sqlite3_stmt *pStmt = 0;
int nCol;
int *aIndex = 0;
int rc;
sprintf(zBuf, "SELECT * FROM %s", zTab);
rc = sqlite3_prepare(db, zBuf, -1, &pStmt, 0);
nCol = sqlite3_column_count(pStmt);
sqlite3_finalize(pStmt);
pStmt = 0;
if( rc!=SQLITE_OK ){
goto get_index_array_out;
}
aIndex = (int *)sqliteMalloc(sizeof(int) * nCol);
if( !aIndex ){
rc = SQLITE_NOMEM;
goto get_index_array_out;
}
sprintf(zBuf, "PRAGMA index_list(%s)", zTab);
rc = sqlite3_prepare(db, zBuf, -1, &pStmt, 0);
while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
sqlite3_stmt *pStmt2 = 0;
sprintf(zBuf, "PRAGMA index_info(%s)", sqlite3_column_text(pStmt, 1));
rc = sqlite3_prepare(db, zBuf, -1, &pStmt2, 0);
if( pStmt2 && sqlite3_step(pStmt2)==SQLITE_ROW ){
int cid = sqlite3_column_int(pStmt2, 1);
assert( cid>=0 && cid<nCol );
aIndex[cid] = 1;
}
rc = sqlite3_finalize(pStmt2);
if( rc!=SQLITE_OK ){
sqlite3_finalize(pStmt);
goto get_index_array_out;
}
}
rc = sqlite3_finalize(pStmt);
get_index_array_out:
if( rc!=SQLITE_OK ){
sqliteFree(aIndex);
aIndex = 0;
}
*paIndex = aIndex;
return rc;
}
/*
** Global Tcl variable $echo_module is a list. This routine appends
** the string element zArg to that list in interpreter interp.
*/
static void appendToEchoModule(Tcl_Interp *interp, const char *zArg){
int flags = (TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_GLOBAL_ONLY);
Tcl_SetVar(interp, "echo_module", (zArg?zArg:""), flags);
}
/*
** This function is called from within the echo-modules xCreate and
** xConnect methods. The argc and argv arguments are copies of those
** passed to the calling method. This function is responsible for
** calling sqlite3_declare_vtab() to declare the schema of the virtual
** table being created or connected.
**
** If the constructor was passed just one argument, i.e.:
**
** CREATE TABLE t1 AS echo(t2);
**
** Then t2 is assumed to be the name of a *real* database table. The
** schema of the virtual table is declared by passing a copy of the
** CREATE TABLE statement for the real table to sqlite3_declare_vtab().
** Hence, the virtual table should have exactly the same column names and
** types as the real table.
*/
static int echoDeclareVtab(
echo_vtab *pVtab,
sqlite3 *db,
int argc,
char **argv
){
int rc = SQLITE_OK;
if( argc==2 ){
sqlite3_stmt *pStmt = 0;
sqlite3_prepare(db,
"SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
-1, &pStmt, 0);
sqlite3_bind_text(pStmt, 1, argv[1], -1, 0);
if( sqlite3_step(pStmt)==SQLITE_ROW ){
const char *zCreateTable = sqlite3_column_text(pStmt, 0);
#ifndef SQLITE_OMIT_VIRTUALTABLE
sqlite3_declare_vtab(db, zCreateTable);
#endif
} else {
rc = SQLITE_ERROR;
}
sqlite3_finalize(pStmt);
if( rc==SQLITE_OK ){
rc = getIndexArray(db, argv[1], &pVtab->aIndex);
}
if( rc==SQLITE_OK ){
rc = getColumnNames(db, argv[1], &pVtab->aCol, &pVtab->nCol);
}
}
return rc;
}
static int echoDestructor(sqlite3_vtab *pVtab){
int ii;
echo_vtab *p = (echo_vtab*)pVtab;
sqliteFree(p->aIndex);
for(ii=0; ii<p->nCol; ii++){
sqliteFree(p->aCol[ii]);
}
sqliteFree(p->aCol);
sqliteFree(p->zTableName);
sqliteFree(p);
return 0;
}
static int echoConstructor(
sqlite3 *db,
void *pAux,
int argc, char **argv,
sqlite3_vtab **ppVtab
){
int i;
echo_vtab *pVtab;
pVtab = sqliteMalloc( sizeof(*pVtab) );
pVtab->interp = (Tcl_Interp *)pAux;
pVtab->db = db;
pVtab->zTableName = sqlite3MPrintf("%s", argv[1]);
for(i=0; i<argc; i++){
appendToEchoModule(pVtab->interp, argv[i]);
}
if( echoDeclareVtab(pVtab, db, argc, argv) ){
echoDestructor((sqlite3_vtab *)pVtab);
return SQLITE_ERROR;
}
*ppVtab = &pVtab->base;
return SQLITE_OK;
}
/* Methods for the echo module */
static int echoCreate(
sqlite3 *db,
void *pAux,
int argc, char **argv,
sqlite3_vtab **ppVtab
){
appendToEchoModule((Tcl_Interp *)(pAux), "xCreate");
return echoConstructor(db, pAux, argc, argv, ppVtab);
}
static int echoConnect(
sqlite3 *db,
void *pAux,
int argc, char **argv,
sqlite3_vtab **ppVtab
){
appendToEchoModule((Tcl_Interp *)(pAux), "xConnect");
return echoConstructor(db, pAux, argc, argv, ppVtab);
}
static int echoDisconnect(sqlite3_vtab *pVtab){
appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDisconnect");
return echoDestructor(pVtab);
}
static int echoDestroy(sqlite3_vtab *pVtab){
appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDestroy");
return echoDestructor(pVtab);
}
static int echoOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
echo_cursor *pCur;
pCur = sqliteMalloc(sizeof(echo_cursor));
*ppCursor = (sqlite3_vtab_cursor *)pCur;
return SQLITE_OK;
}
static int echoClose(sqlite3_vtab_cursor *cur){
echo_cursor *pCur = (echo_cursor *)cur;
sqlite3_finalize(pCur->pStmt);
sqliteFree(pCur);
return SQLITE_OK;
}
static int echoNext(sqlite3_vtab_cursor *cur){
int rc;
echo_cursor *pCur = (echo_cursor *)cur;
rc = sqlite3_step(pCur->pStmt);
if( rc==SQLITE_ROW ){
rc = 1;
} else {
pCur->errcode = sqlite3_finalize(pCur->pStmt);
pCur->pStmt = 0;
rc = 0;
}
return rc;
}
static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
int iCol = i + 1;
sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
assert( sqlite3_data_count(pStmt)>iCol );
sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
return SQLITE_OK;
}
static int echoRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
*pRowid = sqlite3_column_int64(pStmt, 0);
return SQLITE_OK;
}
/*
** Compute a simple hash of the null terminated string zString.
**
** This module uses only sqlite3_index_info.idxStr, not
** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
** in echoBestIndex(), idxNum is set to the corresponding hash value.
** In echoFilter(), code assert()s that the supplied idxNum value is
** indeed the hash of the supplied idxStr.
*/
static int hashString(const char *zString){
int val = 0;
int ii;
for(ii=0; zString[ii]; ii++){
val = (val << 3) + (int)zString[ii];
}
return val;
}
static int echoFilter(
sqlite3_vtab_cursor *pVtabCursor,
int idxNum, const char *idxStr,
int argc, sqlite3_value **argv
){
int rc;
int i;
echo_cursor *pCur = (echo_cursor *)pVtabCursor;
echo_vtab *pVtab = (echo_vtab *)pVtabCursor->pVtab;
sqlite3 *db = pVtab->db;
assert( idxNum==hashString(idxStr) );
sqlite3_finalize(pCur->pStmt);
pCur->pStmt = 0;
rc = sqlite3_prepare(db, idxStr, -1, &pCur->pStmt, 0);
for(i=0; i<argc; i++){
switch( sqlite3_value_type(argv[i]) ){
case SQLITE_INTEGER: {
sqlite3_bind_int64(pCur->pStmt, i+1, sqlite3_value_int64(argv[i]));
break;
}
case SQLITE_FLOAT: {
sqlite3_bind_double(pCur->pStmt, i+1, sqlite3_value_double(argv[i]));
break;
}
case SQLITE_NULL: {
sqlite3_bind_null(pCur->pStmt, i+1);
break;
}
case SQLITE_TEXT: {
sqlite3_bind_text(pCur->pStmt, i+1, sqlite3_value_text(argv[i]),
sqlite3_value_bytes(argv[i]), SQLITE_TRANSIENT);
break;
}
case SQLITE_BLOB: {
sqlite3_bind_blob(pCur->pStmt, i+1, sqlite3_value_blob(argv[i]),
sqlite3_value_bytes(argv[i]), SQLITE_TRANSIENT);
break;
}
}
}
if( rc==SQLITE_OK ){
rc = echoNext(pVtabCursor);
}
appendToEchoModule(pVtab->interp, "xFilter");
appendToEchoModule(pVtab->interp, idxStr);
for(i=0; i<argc; i++){
appendToEchoModule(pVtab->interp, sqlite3_value_text(argv[i]));
}
return rc;
}
/*
** The echo module implements the subset of query constraints and sort
** orders that may take advantage of SQLite indices on the underlying
** real table. For example, if the real table is declared as:
**
** CREATE TABLE real(a, b, c);
** CREATE INDEX real_index ON real(b);
**
** then the echo module handles WHERE or ORDER BY clauses that refer
** to the column "b", but not "a" or "c". If a multi-column index is
** present, only it's left most column is considered.
*/
static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
int ii;
char *zQuery = 0;
char *zNew;
int nArg = 0;
const char *zSep = "WHERE";
echo_vtab *pVtab = (echo_vtab *)tab;
zQuery = sqlite3_mprintf("SELECT rowid, * FROM %Q", pVtab->zTableName);
for(ii=0; ii<pIdxInfo->nConstraint; ii++){
const struct sqlite3_index_constraint *pConstraint;
struct sqlite3_index_constraint_usage *pUsage;
pConstraint = &pIdxInfo->aConstraint[ii];
pUsage = &pIdxInfo->aConstraintUsage[ii];
int iCol = pConstraint->iColumn;
if( pVtab->aIndex[iCol] ){
char *zCol = pVtab->aCol[iCol];
char *zOp = 0;
switch( pConstraint->op ){
case SQLITE_INDEX_CONSTRAINT_EQ:
zOp = "="; break;
case SQLITE_INDEX_CONSTRAINT_LT:
zOp = "<"; break;
case SQLITE_INDEX_CONSTRAINT_GT:
zOp = ">"; break;
case SQLITE_INDEX_CONSTRAINT_LE:
zOp = "<="; break;
case SQLITE_INDEX_CONSTRAINT_GE:
zOp = ">="; break;
case SQLITE_INDEX_CONSTRAINT_MATCH:
zOp = "MATCH"; break;
}
zNew = sqlite3_mprintf("%s %s %s %s ?", zQuery, zSep, zCol, zOp);
sqlite3_free(zQuery);
zQuery = zNew;
zSep = "AND";
pUsage->argvIndex = ++nArg;
pUsage->omit = 1;
}
}
/* If there is only one term in the ORDER BY clause, and it is
** on a column that this virtual table has an index for, then consume
** the ORDER BY clause.
*/
if( pIdxInfo->nOrderBy==1 && pVtab->aIndex[pIdxInfo->aOrderBy->iColumn] ){
char *zCol = pVtab->aCol[pIdxInfo->aOrderBy->iColumn];
char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
zNew = sqlite3_mprintf("%s ORDER BY %s %s", zQuery, zCol, zDir);
sqlite3_free(zQuery);
zQuery = zNew;
pIdxInfo->orderByConsumed = 1;
}
appendToEchoModule(pVtab->interp, "xBestIndex");;
appendToEchoModule(pVtab->interp, zQuery);
pIdxInfo->idxNum = hashString(zQuery);
pIdxInfo->idxStr = zQuery;
pIdxInfo->needToFreeIdxStr = 1;
pIdxInfo->estimatedCost = 1.0;
return SQLITE_OK;
}
/*
** A virtual table module that merely echos method calls into TCL
** variables.
*/
static sqlite3_module echoModule = {
0, /* iVersion */
"echo", /* zName */
0, /* pAux */
echoCreate,
echoConnect,
echoBestIndex,
echoDisconnect,
echoDestroy,
echoOpen, /* xOpen - open a cursor */
echoClose, /* xClose - close a cursor */
echoFilter, /* xFilter - configure scan constraints */
echoNext, /* xNext - advance a cursor */
echoColumn, /* xColumn - read data */
echoRowid /* xRowid - read data */
};
/*
** Decode a pointer to an sqlite3 object.
*/
static int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb){
*ppDb = (sqlite3*)sqlite3TextToPtr(zA);
return TCL_OK;
}
/*
** Register the echo virtual table module.
*/
static int register_echo_module(
ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
int objc, /* Number of arguments */
Tcl_Obj *CONST objv[] /* Command arguments */
){
sqlite3 *db;
if( objc!=2 ){
Tcl_WrongNumArgs(interp, 1, objv, "DB");
return TCL_ERROR;
}
if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
echoModule.pAux = interp;
#ifndef SQLITE_OMIT_VIRTUALTABLE
sqlite3_create_module(db, "echo", &echoModule);
#endif
return TCL_OK;
}
/*
** Register commands with the TCL interpreter.
*/
int Sqlitetest8_Init(Tcl_Interp *interp){
static struct {
char *zName;
Tcl_ObjCmdProc *xProc;
void *clientData;
} aObjCmd[] = {
{ "register_echo_module", register_echo_module, 0 },
};
int i;
for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
}
return TCL_OK;
}