1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/SRC/test8.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1343 @@
1.4 +/*
1.5 +** 2006 June 10
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** Code for testing the virtual table interfaces. This code
1.16 +** is not included in the SQLite library. It is used for automated
1.17 +** testing of the SQLite library.
1.18 +**
1.19 +** $Id: test8.c,v 1.75 2008/08/31 00:29:08 shane Exp $
1.20 +*/
1.21 +#include "sqliteInt.h"
1.22 +#include "tcl.h"
1.23 +#include <stdlib.h>
1.24 +#include <string.h>
1.25 +
1.26 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.27 +
1.28 +typedef struct echo_vtab echo_vtab;
1.29 +typedef struct echo_cursor echo_cursor;
1.30 +
1.31 +/*
1.32 +** The test module defined in this file uses four global Tcl variables to
1.33 +** commicate with test-scripts:
1.34 +**
1.35 +** $::echo_module
1.36 +** $::echo_module_sync_fail
1.37 +** $::echo_module_begin_fail
1.38 +** $::echo_module_cost
1.39 +**
1.40 +** The variable ::echo_module is a list. Each time one of the following
1.41 +** methods is called, one or more elements are appended to the list.
1.42 +** This is used for automated testing of virtual table modules.
1.43 +**
1.44 +** The ::echo_module_sync_fail variable is set by test scripts and read
1.45 +** by code in this file. If it is set to the name of a real table in the
1.46 +** the database, then all xSync operations on echo virtual tables that
1.47 +** use the named table as a backing store will fail.
1.48 +*/
1.49 +
1.50 +/*
1.51 +** Errors can be provoked within the following echo virtual table methods:
1.52 +**
1.53 +** xBestIndex xOpen xFilter xNext
1.54 +** xColumn xRowid xUpdate xSync
1.55 +** xBegin xRename
1.56 +**
1.57 +** This is done by setting the global tcl variable:
1.58 +**
1.59 +** echo_module_fail($method,$tbl)
1.60 +**
1.61 +** where $method is set to the name of the virtual table method to fail
1.62 +** (i.e. "xBestIndex") and $tbl is the name of the table being echoed (not
1.63 +** the name of the virtual table, the name of the underlying real table).
1.64 +*/
1.65 +
1.66 +/*
1.67 +** An echo virtual-table object.
1.68 +**
1.69 +** echo.vtab.aIndex is an array of booleans. The nth entry is true if
1.70 +** the nth column of the real table is the left-most column of an index
1.71 +** (implicit or otherwise). In other words, if SQLite can optimize
1.72 +** a query like "SELECT * FROM real_table WHERE col = ?".
1.73 +**
1.74 +** Member variable aCol[] contains copies of the column names of the real
1.75 +** table.
1.76 +*/
1.77 +struct echo_vtab {
1.78 + sqlite3_vtab base;
1.79 + Tcl_Interp *interp; /* Tcl interpreter containing debug variables */
1.80 + sqlite3 *db; /* Database connection */
1.81 +
1.82 + int isPattern;
1.83 + int inTransaction; /* True if within a transaction */
1.84 + char *zThis; /* Name of the echo table */
1.85 + char *zTableName; /* Name of the real table */
1.86 + char *zLogName; /* Name of the log table */
1.87 + int nCol; /* Number of columns in the real table */
1.88 + int *aIndex; /* Array of size nCol. True if column has an index */
1.89 + char **aCol; /* Array of size nCol. Column names */
1.90 +};
1.91 +
1.92 +/* An echo cursor object */
1.93 +struct echo_cursor {
1.94 + sqlite3_vtab_cursor base;
1.95 + sqlite3_stmt *pStmt;
1.96 +};
1.97 +
1.98 +static int simulateVtabError(echo_vtab *p, const char *zMethod){
1.99 + const char *zErr;
1.100 + char zVarname[128];
1.101 + zVarname[127] = '\0';
1.102 + sqlite3_snprintf(127, zVarname, "echo_module_fail(%s,%s)", zMethod, p->zTableName);
1.103 + zErr = Tcl_GetVar(p->interp, zVarname, TCL_GLOBAL_ONLY);
1.104 + if( zErr ){
1.105 + p->base.zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", zErr);
1.106 + }
1.107 + return (zErr!=0);
1.108 +}
1.109 +
1.110 +/*
1.111 +** Convert an SQL-style quoted string into a normal string by removing
1.112 +** the quote characters. The conversion is done in-place. If the
1.113 +** input does not begin with a quote character, then this routine
1.114 +** is a no-op.
1.115 +**
1.116 +** Examples:
1.117 +**
1.118 +** "abc" becomes abc
1.119 +** 'xyz' becomes xyz
1.120 +** [pqr] becomes pqr
1.121 +** `mno` becomes mno
1.122 +*/
1.123 +static void dequoteString(char *z){
1.124 + int quote;
1.125 + int i, j;
1.126 + if( z==0 ) return;
1.127 + quote = z[0];
1.128 + switch( quote ){
1.129 + case '\'': break;
1.130 + case '"': break;
1.131 + case '`': break; /* For MySQL compatibility */
1.132 + case '[': quote = ']'; break; /* For MS SqlServer compatibility */
1.133 + default: return;
1.134 + }
1.135 + for(i=1, j=0; z[i]; i++){
1.136 + if( z[i]==quote ){
1.137 + if( z[i+1]==quote ){
1.138 + z[j++] = quote;
1.139 + i++;
1.140 + }else{
1.141 + z[j++] = 0;
1.142 + break;
1.143 + }
1.144 + }else{
1.145 + z[j++] = z[i];
1.146 + }
1.147 + }
1.148 +}
1.149 +
1.150 +/*
1.151 +** Retrieve the column names for the table named zTab via database
1.152 +** connection db. SQLITE_OK is returned on success, or an sqlite error
1.153 +** code otherwise.
1.154 +**
1.155 +** If successful, the number of columns is written to *pnCol. *paCol is
1.156 +** set to point at sqlite3_malloc()'d space containing the array of
1.157 +** nCol column names. The caller is responsible for calling sqlite3_free
1.158 +** on *paCol.
1.159 +*/
1.160 +static int getColumnNames(
1.161 + sqlite3 *db,
1.162 + const char *zTab,
1.163 + char ***paCol,
1.164 + int *pnCol
1.165 +){
1.166 + char **aCol = 0;
1.167 + char *zSql;
1.168 + sqlite3_stmt *pStmt = 0;
1.169 + int rc = SQLITE_OK;
1.170 + int nCol = 0;
1.171 +
1.172 + /* Prepare the statement "SELECT * FROM <tbl>". The column names
1.173 + ** of the result set of the compiled SELECT will be the same as
1.174 + ** the column names of table <tbl>.
1.175 + */
1.176 + zSql = sqlite3_mprintf("SELECT * FROM %Q", zTab);
1.177 + if( !zSql ){
1.178 + rc = SQLITE_NOMEM;
1.179 + goto out;
1.180 + }
1.181 + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
1.182 + sqlite3_free(zSql);
1.183 +
1.184 + if( rc==SQLITE_OK ){
1.185 + int ii;
1.186 + int nBytes;
1.187 + char *zSpace;
1.188 + nCol = sqlite3_column_count(pStmt);
1.189 +
1.190 + /* Figure out how much space to allocate for the array of column names
1.191 + ** (including space for the strings themselves). Then allocate it.
1.192 + */
1.193 + nBytes = sizeof(char *) * nCol;
1.194 + for(ii=0; ii<nCol; ii++){
1.195 + const char *zName = sqlite3_column_name(pStmt, ii);
1.196 + if( !zName ){
1.197 + rc = SQLITE_NOMEM;
1.198 + goto out;
1.199 + }
1.200 + nBytes += strlen(zName)+1;
1.201 + }
1.202 + aCol = (char **)sqlite3MallocZero(nBytes);
1.203 + if( !aCol ){
1.204 + rc = SQLITE_NOMEM;
1.205 + goto out;
1.206 + }
1.207 +
1.208 + /* Copy the column names into the allocated space and set up the
1.209 + ** pointers in the aCol[] array.
1.210 + */
1.211 + zSpace = (char *)(&aCol[nCol]);
1.212 + for(ii=0; ii<nCol; ii++){
1.213 + aCol[ii] = zSpace;
1.214 + zSpace += sprintf(zSpace, "%s", sqlite3_column_name(pStmt, ii));
1.215 + zSpace++;
1.216 + }
1.217 + assert( (zSpace-nBytes)==(char *)aCol );
1.218 + }
1.219 +
1.220 + *paCol = aCol;
1.221 + *pnCol = nCol;
1.222 +
1.223 +out:
1.224 + sqlite3_finalize(pStmt);
1.225 + return rc;
1.226 +}
1.227 +
1.228 +/*
1.229 +** Parameter zTab is the name of a table in database db with nCol
1.230 +** columns. This function allocates an array of integers nCol in
1.231 +** size and populates it according to any implicit or explicit
1.232 +** indices on table zTab.
1.233 +**
1.234 +** If successful, SQLITE_OK is returned and *paIndex set to point
1.235 +** at the allocated array. Otherwise, an error code is returned.
1.236 +**
1.237 +** See comments associated with the member variable aIndex above
1.238 +** "struct echo_vtab" for details of the contents of the array.
1.239 +*/
1.240 +static int getIndexArray(
1.241 + sqlite3 *db, /* Database connection */
1.242 + const char *zTab, /* Name of table in database db */
1.243 + int nCol,
1.244 + int **paIndex
1.245 +){
1.246 + sqlite3_stmt *pStmt = 0;
1.247 + int *aIndex = 0;
1.248 + int rc;
1.249 + char *zSql;
1.250 +
1.251 + /* Allocate space for the index array */
1.252 + aIndex = (int *)sqlite3MallocZero(sizeof(int) * nCol);
1.253 + if( !aIndex ){
1.254 + rc = SQLITE_NOMEM;
1.255 + goto get_index_array_out;
1.256 + }
1.257 +
1.258 + /* Compile an sqlite pragma to loop through all indices on table zTab */
1.259 + zSql = sqlite3MPrintf(0, "PRAGMA index_list(%s)", zTab);
1.260 + if( !zSql ){
1.261 + rc = SQLITE_NOMEM;
1.262 + goto get_index_array_out;
1.263 + }
1.264 + rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
1.265 + sqlite3_free(zSql);
1.266 +
1.267 + /* For each index, figure out the left-most column and set the
1.268 + ** corresponding entry in aIndex[] to 1.
1.269 + */
1.270 + while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
1.271 + const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
1.272 + sqlite3_stmt *pStmt2 = 0;
1.273 + zSql = sqlite3MPrintf(0, "PRAGMA index_info(%s)", zIdx);
1.274 + if( !zSql ){
1.275 + rc = SQLITE_NOMEM;
1.276 + goto get_index_array_out;
1.277 + }
1.278 + rc = sqlite3_prepare(db, zSql, -1, &pStmt2, 0);
1.279 + sqlite3_free(zSql);
1.280 + if( pStmt2 && sqlite3_step(pStmt2)==SQLITE_ROW ){
1.281 + int cid = sqlite3_column_int(pStmt2, 1);
1.282 + assert( cid>=0 && cid<nCol );
1.283 + aIndex[cid] = 1;
1.284 + }
1.285 + if( pStmt2 ){
1.286 + rc = sqlite3_finalize(pStmt2);
1.287 + }
1.288 + if( rc!=SQLITE_OK ){
1.289 + goto get_index_array_out;
1.290 + }
1.291 + }
1.292 +
1.293 +
1.294 +get_index_array_out:
1.295 + if( pStmt ){
1.296 + int rc2 = sqlite3_finalize(pStmt);
1.297 + if( rc==SQLITE_OK ){
1.298 + rc = rc2;
1.299 + }
1.300 + }
1.301 + if( rc!=SQLITE_OK ){
1.302 + sqlite3_free(aIndex);
1.303 + aIndex = 0;
1.304 + }
1.305 + *paIndex = aIndex;
1.306 + return rc;
1.307 +}
1.308 +
1.309 +/*
1.310 +** Global Tcl variable $echo_module is a list. This routine appends
1.311 +** the string element zArg to that list in interpreter interp.
1.312 +*/
1.313 +static void appendToEchoModule(Tcl_Interp *interp, const char *zArg){
1.314 + int flags = (TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_GLOBAL_ONLY);
1.315 + Tcl_SetVar(interp, "echo_module", (zArg?zArg:""), flags);
1.316 +}
1.317 +
1.318 +/*
1.319 +** This function is called from within the echo-modules xCreate and
1.320 +** xConnect methods. The argc and argv arguments are copies of those
1.321 +** passed to the calling method. This function is responsible for
1.322 +** calling sqlite3_declare_vtab() to declare the schema of the virtual
1.323 +** table being created or connected.
1.324 +**
1.325 +** If the constructor was passed just one argument, i.e.:
1.326 +**
1.327 +** CREATE TABLE t1 AS echo(t2);
1.328 +**
1.329 +** Then t2 is assumed to be the name of a *real* database table. The
1.330 +** schema of the virtual table is declared by passing a copy of the
1.331 +** CREATE TABLE statement for the real table to sqlite3_declare_vtab().
1.332 +** Hence, the virtual table should have exactly the same column names and
1.333 +** types as the real table.
1.334 +*/
1.335 +static int echoDeclareVtab(
1.336 + echo_vtab *pVtab,
1.337 + sqlite3 *db
1.338 +){
1.339 + int rc = SQLITE_OK;
1.340 +
1.341 + if( pVtab->zTableName ){
1.342 + sqlite3_stmt *pStmt = 0;
1.343 + rc = sqlite3_prepare(db,
1.344 + "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
1.345 + -1, &pStmt, 0);
1.346 + if( rc==SQLITE_OK ){
1.347 + sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
1.348 + if( sqlite3_step(pStmt)==SQLITE_ROW ){
1.349 + int rc2;
1.350 + const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
1.351 + rc = sqlite3_declare_vtab(db, zCreateTable);
1.352 + rc2 = sqlite3_finalize(pStmt);
1.353 + if( rc==SQLITE_OK ){
1.354 + rc = rc2;
1.355 + }
1.356 + } else {
1.357 + rc = sqlite3_finalize(pStmt);
1.358 + if( rc==SQLITE_OK ){
1.359 + rc = SQLITE_ERROR;
1.360 + }
1.361 + }
1.362 + if( rc==SQLITE_OK ){
1.363 + rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
1.364 + }
1.365 + if( rc==SQLITE_OK ){
1.366 + rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
1.367 + }
1.368 + }
1.369 + }
1.370 +
1.371 + return rc;
1.372 +}
1.373 +
1.374 +/*
1.375 +** This function frees all runtime structures associated with the virtual
1.376 +** table pVtab.
1.377 +*/
1.378 +static int echoDestructor(sqlite3_vtab *pVtab){
1.379 + echo_vtab *p = (echo_vtab*)pVtab;
1.380 + sqlite3_free(p->aIndex);
1.381 + sqlite3_free(p->aCol);
1.382 + sqlite3_free(p->zThis);
1.383 + sqlite3_free(p->zTableName);
1.384 + sqlite3_free(p->zLogName);
1.385 + sqlite3_free(p);
1.386 + return 0;
1.387 +}
1.388 +
1.389 +typedef struct EchoModule EchoModule;
1.390 +struct EchoModule {
1.391 + Tcl_Interp *interp;
1.392 +};
1.393 +
1.394 +/*
1.395 +** This function is called to do the work of the xConnect() method -
1.396 +** to allocate the required in-memory structures for a newly connected
1.397 +** virtual table.
1.398 +*/
1.399 +static int echoConstructor(
1.400 + sqlite3 *db,
1.401 + void *pAux,
1.402 + int argc, const char *const*argv,
1.403 + sqlite3_vtab **ppVtab,
1.404 + char **pzErr
1.405 +){
1.406 + int rc;
1.407 + int i;
1.408 + echo_vtab *pVtab;
1.409 +
1.410 + /* Allocate the sqlite3_vtab/echo_vtab structure itself */
1.411 + pVtab = sqlite3MallocZero( sizeof(*pVtab) );
1.412 + if( !pVtab ){
1.413 + return SQLITE_NOMEM;
1.414 + }
1.415 + pVtab->interp = ((EchoModule *)pAux)->interp;
1.416 + pVtab->db = db;
1.417 +
1.418 + /* Allocate echo_vtab.zThis */
1.419 + pVtab->zThis = sqlite3MPrintf(0, "%s", argv[2]);
1.420 + if( !pVtab->zThis ){
1.421 + echoDestructor((sqlite3_vtab *)pVtab);
1.422 + return SQLITE_NOMEM;
1.423 + }
1.424 +
1.425 + /* Allocate echo_vtab.zTableName */
1.426 + if( argc>3 ){
1.427 + pVtab->zTableName = sqlite3MPrintf(0, "%s", argv[3]);
1.428 + dequoteString(pVtab->zTableName);
1.429 + if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){
1.430 + char *z = sqlite3MPrintf(0, "%s%s", argv[2], &(pVtab->zTableName[1]));
1.431 + sqlite3_free(pVtab->zTableName);
1.432 + pVtab->zTableName = z;
1.433 + pVtab->isPattern = 1;
1.434 + }
1.435 + if( !pVtab->zTableName ){
1.436 + echoDestructor((sqlite3_vtab *)pVtab);
1.437 + return SQLITE_NOMEM;
1.438 + }
1.439 + }
1.440 +
1.441 + /* Log the arguments to this function to Tcl var ::echo_module */
1.442 + for(i=0; i<argc; i++){
1.443 + appendToEchoModule(pVtab->interp, argv[i]);
1.444 + }
1.445 +
1.446 + /* Invoke sqlite3_declare_vtab and set up other members of the echo_vtab
1.447 + ** structure. If an error occurs, delete the sqlite3_vtab structure and
1.448 + ** return an error code.
1.449 + */
1.450 + rc = echoDeclareVtab(pVtab, db);
1.451 + if( rc!=SQLITE_OK ){
1.452 + echoDestructor((sqlite3_vtab *)pVtab);
1.453 + return rc;
1.454 + }
1.455 +
1.456 + /* Success. Set *ppVtab and return */
1.457 + *ppVtab = &pVtab->base;
1.458 + return SQLITE_OK;
1.459 +}
1.460 +
1.461 +/*
1.462 +** Echo virtual table module xCreate method.
1.463 +*/
1.464 +static int echoCreate(
1.465 + sqlite3 *db,
1.466 + void *pAux,
1.467 + int argc, const char *const*argv,
1.468 + sqlite3_vtab **ppVtab,
1.469 + char **pzErr
1.470 +){
1.471 + int rc = SQLITE_OK;
1.472 + appendToEchoModule(((EchoModule *)pAux)->interp, "xCreate");
1.473 + rc = echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
1.474 +
1.475 + /* If there were two arguments passed to the module at the SQL level
1.476 + ** (i.e. "CREATE VIRTUAL TABLE tbl USING echo(arg1, arg2)"), then
1.477 + ** the second argument is used as a table name. Attempt to create
1.478 + ** such a table with a single column, "logmsg". This table will
1.479 + ** be used to log calls to the xUpdate method. It will be deleted
1.480 + ** when the virtual table is DROPed.
1.481 + **
1.482 + ** Note: The main point of this is to test that we can drop tables
1.483 + ** from within an xDestroy method call.
1.484 + */
1.485 + if( rc==SQLITE_OK && argc==5 ){
1.486 + char *zSql;
1.487 + echo_vtab *pVtab = *(echo_vtab **)ppVtab;
1.488 + pVtab->zLogName = sqlite3MPrintf(0, "%s", argv[4]);
1.489 + zSql = sqlite3MPrintf(0, "CREATE TABLE %Q(logmsg)", pVtab->zLogName);
1.490 + rc = sqlite3_exec(db, zSql, 0, 0, 0);
1.491 + sqlite3_free(zSql);
1.492 + if( rc!=SQLITE_OK ){
1.493 + *pzErr = sqlite3DbStrDup(0, sqlite3_errmsg(db));
1.494 + }
1.495 + }
1.496 +
1.497 + if( *ppVtab && rc!=SQLITE_OK ){
1.498 + echoDestructor(*ppVtab);
1.499 + *ppVtab = 0;
1.500 + }
1.501 +
1.502 + if( rc==SQLITE_OK ){
1.503 + (*(echo_vtab**)ppVtab)->inTransaction = 1;
1.504 + }
1.505 +
1.506 + return rc;
1.507 +}
1.508 +
1.509 +/*
1.510 +** Echo virtual table module xConnect method.
1.511 +*/
1.512 +static int echoConnect(
1.513 + sqlite3 *db,
1.514 + void *pAux,
1.515 + int argc, const char *const*argv,
1.516 + sqlite3_vtab **ppVtab,
1.517 + char **pzErr
1.518 +){
1.519 + appendToEchoModule(((EchoModule *)pAux)->interp, "xConnect");
1.520 + return echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
1.521 +}
1.522 +
1.523 +/*
1.524 +** Echo virtual table module xDisconnect method.
1.525 +*/
1.526 +static int echoDisconnect(sqlite3_vtab *pVtab){
1.527 + appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDisconnect");
1.528 + return echoDestructor(pVtab);
1.529 +}
1.530 +
1.531 +/*
1.532 +** Echo virtual table module xDestroy method.
1.533 +*/
1.534 +static int echoDestroy(sqlite3_vtab *pVtab){
1.535 + int rc = SQLITE_OK;
1.536 + echo_vtab *p = (echo_vtab *)pVtab;
1.537 + appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDestroy");
1.538 +
1.539 + /* Drop the "log" table, if one exists (see echoCreate() for details) */
1.540 + if( p && p->zLogName ){
1.541 + char *zSql;
1.542 + zSql = sqlite3MPrintf(0, "DROP TABLE %Q", p->zLogName);
1.543 + rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
1.544 + sqlite3_free(zSql);
1.545 + }
1.546 +
1.547 + if( rc==SQLITE_OK ){
1.548 + rc = echoDestructor(pVtab);
1.549 + }
1.550 + return rc;
1.551 +}
1.552 +
1.553 +/*
1.554 +** Echo virtual table module xOpen method.
1.555 +*/
1.556 +static int echoOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
1.557 + echo_cursor *pCur;
1.558 + if( simulateVtabError((echo_vtab *)pVTab, "xOpen") ){
1.559 + return SQLITE_ERROR;
1.560 + }
1.561 + pCur = sqlite3MallocZero(sizeof(echo_cursor));
1.562 + *ppCursor = (sqlite3_vtab_cursor *)pCur;
1.563 + return (pCur ? SQLITE_OK : SQLITE_NOMEM);
1.564 +}
1.565 +
1.566 +/*
1.567 +** Echo virtual table module xClose method.
1.568 +*/
1.569 +static int echoClose(sqlite3_vtab_cursor *cur){
1.570 + int rc;
1.571 + echo_cursor *pCur = (echo_cursor *)cur;
1.572 + sqlite3_stmt *pStmt = pCur->pStmt;
1.573 + pCur->pStmt = 0;
1.574 + sqlite3_free(pCur);
1.575 + rc = sqlite3_finalize(pStmt);
1.576 + return rc;
1.577 +}
1.578 +
1.579 +/*
1.580 +** Return non-zero if the cursor does not currently point to a valid record
1.581 +** (i.e if the scan has finished), or zero otherwise.
1.582 +*/
1.583 +static int echoEof(sqlite3_vtab_cursor *cur){
1.584 + return (((echo_cursor *)cur)->pStmt ? 0 : 1);
1.585 +}
1.586 +
1.587 +/*
1.588 +** Echo virtual table module xNext method.
1.589 +*/
1.590 +static int echoNext(sqlite3_vtab_cursor *cur){
1.591 + int rc = SQLITE_OK;
1.592 + echo_cursor *pCur = (echo_cursor *)cur;
1.593 +
1.594 + if( simulateVtabError((echo_vtab *)(cur->pVtab), "xNext") ){
1.595 + return SQLITE_ERROR;
1.596 + }
1.597 +
1.598 + if( pCur->pStmt ){
1.599 + rc = sqlite3_step(pCur->pStmt);
1.600 + if( rc==SQLITE_ROW ){
1.601 + rc = SQLITE_OK;
1.602 + }else{
1.603 + rc = sqlite3_finalize(pCur->pStmt);
1.604 + pCur->pStmt = 0;
1.605 + }
1.606 + }
1.607 +
1.608 + return rc;
1.609 +}
1.610 +
1.611 +/*
1.612 +** Echo virtual table module xColumn method.
1.613 +*/
1.614 +static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
1.615 + int iCol = i + 1;
1.616 + sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
1.617 +
1.618 + if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){
1.619 + return SQLITE_ERROR;
1.620 + }
1.621 +
1.622 + if( !pStmt ){
1.623 + sqlite3_result_null(ctx);
1.624 + }else{
1.625 + assert( sqlite3_data_count(pStmt)>iCol );
1.626 + sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
1.627 + }
1.628 + return SQLITE_OK;
1.629 +}
1.630 +
1.631 +/*
1.632 +** Echo virtual table module xRowid method.
1.633 +*/
1.634 +static int echoRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
1.635 + sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
1.636 +
1.637 + if( simulateVtabError((echo_vtab *)(cur->pVtab), "xRowid") ){
1.638 + return SQLITE_ERROR;
1.639 + }
1.640 +
1.641 + *pRowid = sqlite3_column_int64(pStmt, 0);
1.642 + return SQLITE_OK;
1.643 +}
1.644 +
1.645 +/*
1.646 +** Compute a simple hash of the null terminated string zString.
1.647 +**
1.648 +** This module uses only sqlite3_index_info.idxStr, not
1.649 +** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
1.650 +** in echoBestIndex(), idxNum is set to the corresponding hash value.
1.651 +** In echoFilter(), code assert()s that the supplied idxNum value is
1.652 +** indeed the hash of the supplied idxStr.
1.653 +*/
1.654 +static int hashString(const char *zString){
1.655 + int val = 0;
1.656 + int ii;
1.657 + for(ii=0; zString[ii]; ii++){
1.658 + val = (val << 3) + (int)zString[ii];
1.659 + }
1.660 + return val;
1.661 +}
1.662 +
1.663 +/*
1.664 +** Echo virtual table module xFilter method.
1.665 +*/
1.666 +static int echoFilter(
1.667 + sqlite3_vtab_cursor *pVtabCursor,
1.668 + int idxNum, const char *idxStr,
1.669 + int argc, sqlite3_value **argv
1.670 +){
1.671 + int rc;
1.672 + int i;
1.673 +
1.674 + echo_cursor *pCur = (echo_cursor *)pVtabCursor;
1.675 + echo_vtab *pVtab = (echo_vtab *)pVtabCursor->pVtab;
1.676 + sqlite3 *db = pVtab->db;
1.677 +
1.678 + if( simulateVtabError(pVtab, "xFilter") ){
1.679 + return SQLITE_ERROR;
1.680 + }
1.681 +
1.682 + /* Check that idxNum matches idxStr */
1.683 + assert( idxNum==hashString(idxStr) );
1.684 +
1.685 + /* Log arguments to the ::echo_module Tcl variable */
1.686 + appendToEchoModule(pVtab->interp, "xFilter");
1.687 + appendToEchoModule(pVtab->interp, idxStr);
1.688 + for(i=0; i<argc; i++){
1.689 + appendToEchoModule(pVtab->interp, (const char*)sqlite3_value_text(argv[i]));
1.690 + }
1.691 +
1.692 + sqlite3_finalize(pCur->pStmt);
1.693 + pCur->pStmt = 0;
1.694 +
1.695 + /* Prepare the SQL statement created by echoBestIndex and bind the
1.696 + ** runtime parameters passed to this function to it.
1.697 + */
1.698 + rc = sqlite3_prepare(db, idxStr, -1, &pCur->pStmt, 0);
1.699 + assert( pCur->pStmt || rc!=SQLITE_OK );
1.700 + for(i=0; rc==SQLITE_OK && i<argc; i++){
1.701 + sqlite3_bind_value(pCur->pStmt, i+1, argv[i]);
1.702 + }
1.703 +
1.704 + /* If everything was successful, advance to the first row of the scan */
1.705 + if( rc==SQLITE_OK ){
1.706 + rc = echoNext(pVtabCursor);
1.707 + }
1.708 +
1.709 + return rc;
1.710 +}
1.711 +
1.712 +
1.713 +/*
1.714 +** A helper function used by echoUpdate() and echoBestIndex() for
1.715 +** manipulating strings in concert with the sqlite3_mprintf() function.
1.716 +**
1.717 +** Parameter pzStr points to a pointer to a string allocated with
1.718 +** sqlite3_mprintf. The second parameter, zAppend, points to another
1.719 +** string. The two strings are concatenated together and *pzStr
1.720 +** set to point at the result. The initial buffer pointed to by *pzStr
1.721 +** is deallocated via sqlite3_free().
1.722 +**
1.723 +** If the third argument, doFree, is true, then sqlite3_free() is
1.724 +** also called to free the buffer pointed to by zAppend.
1.725 +*/
1.726 +static void string_concat(char **pzStr, char *zAppend, int doFree, int *pRc){
1.727 + char *zIn = *pzStr;
1.728 + if( !zAppend && doFree && *pRc==SQLITE_OK ){
1.729 + *pRc = SQLITE_NOMEM;
1.730 + }
1.731 + if( *pRc!=SQLITE_OK ){
1.732 + sqlite3_free(zIn);
1.733 + zIn = 0;
1.734 + }else{
1.735 + if( zIn ){
1.736 + char *zTemp = zIn;
1.737 + zIn = sqlite3_mprintf("%s%s", zIn, zAppend);
1.738 + sqlite3_free(zTemp);
1.739 + }else{
1.740 + zIn = sqlite3_mprintf("%s", zAppend);
1.741 + }
1.742 + if( !zIn ){
1.743 + *pRc = SQLITE_NOMEM;
1.744 + }
1.745 + }
1.746 + *pzStr = zIn;
1.747 + if( doFree ){
1.748 + sqlite3_free(zAppend);
1.749 + }
1.750 +}
1.751 +
1.752 +/*
1.753 +** The echo module implements the subset of query constraints and sort
1.754 +** orders that may take advantage of SQLite indices on the underlying
1.755 +** real table. For example, if the real table is declared as:
1.756 +**
1.757 +** CREATE TABLE real(a, b, c);
1.758 +** CREATE INDEX real_index ON real(b);
1.759 +**
1.760 +** then the echo module handles WHERE or ORDER BY clauses that refer
1.761 +** to the column "b", but not "a" or "c". If a multi-column index is
1.762 +** present, only its left most column is considered.
1.763 +**
1.764 +** This xBestIndex method encodes the proposed search strategy as
1.765 +** an SQL query on the real table underlying the virtual echo module
1.766 +** table and stores the query in sqlite3_index_info.idxStr. The SQL
1.767 +** statement is of the form:
1.768 +**
1.769 +** SELECT rowid, * FROM <real-table> ?<where-clause>? ?<order-by-clause>?
1.770 +**
1.771 +** where the <where-clause> and <order-by-clause> are determined
1.772 +** by the contents of the structure pointed to by the pIdxInfo argument.
1.773 +*/
1.774 +static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
1.775 + int ii;
1.776 + char *zQuery = 0;
1.777 + char *zNew;
1.778 + int nArg = 0;
1.779 + const char *zSep = "WHERE";
1.780 + echo_vtab *pVtab = (echo_vtab *)tab;
1.781 + sqlite3_stmt *pStmt = 0;
1.782 + Tcl_Interp *interp = pVtab->interp;
1.783 +
1.784 + int nRow;
1.785 + int useIdx = 0;
1.786 + int rc = SQLITE_OK;
1.787 + int useCost = 0;
1.788 + double cost;
1.789 + int isIgnoreUsable = 0;
1.790 + if( Tcl_GetVar(interp, "echo_module_ignore_usable", TCL_GLOBAL_ONLY) ){
1.791 + isIgnoreUsable = 1;
1.792 + }
1.793 +
1.794 + if( simulateVtabError(pVtab, "xBestIndex") ){
1.795 + return SQLITE_ERROR;
1.796 + }
1.797 +
1.798 + /* Determine the number of rows in the table and store this value in local
1.799 + ** variable nRow. The 'estimated-cost' of the scan will be the number of
1.800 + ** rows in the table for a linear scan, or the log (base 2) of the
1.801 + ** number of rows if the proposed scan uses an index.
1.802 + */
1.803 + if( Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY) ){
1.804 + cost = atof(Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY));
1.805 + useCost = 1;
1.806 + } else {
1.807 + zQuery = sqlite3_mprintf("SELECT count(*) FROM %Q", pVtab->zTableName);
1.808 + if( !zQuery ){
1.809 + return SQLITE_NOMEM;
1.810 + }
1.811 + rc = sqlite3_prepare(pVtab->db, zQuery, -1, &pStmt, 0);
1.812 + sqlite3_free(zQuery);
1.813 + if( rc!=SQLITE_OK ){
1.814 + return rc;
1.815 + }
1.816 + sqlite3_step(pStmt);
1.817 + nRow = sqlite3_column_int(pStmt, 0);
1.818 + rc = sqlite3_finalize(pStmt);
1.819 + if( rc!=SQLITE_OK ){
1.820 + return rc;
1.821 + }
1.822 + }
1.823 +
1.824 + zQuery = sqlite3_mprintf("SELECT rowid, * FROM %Q", pVtab->zTableName);
1.825 + if( !zQuery ){
1.826 + return SQLITE_NOMEM;
1.827 + }
1.828 + for(ii=0; ii<pIdxInfo->nConstraint; ii++){
1.829 + const struct sqlite3_index_constraint *pConstraint;
1.830 + struct sqlite3_index_constraint_usage *pUsage;
1.831 + int iCol;
1.832 +
1.833 + pConstraint = &pIdxInfo->aConstraint[ii];
1.834 + pUsage = &pIdxInfo->aConstraintUsage[ii];
1.835 +
1.836 + if( !isIgnoreUsable && !pConstraint->usable ) continue;
1.837 +
1.838 + iCol = pConstraint->iColumn;
1.839 + if( pVtab->aIndex[iCol] || iCol<0 ){
1.840 + char *zCol = pVtab->aCol[iCol];
1.841 + char *zOp = 0;
1.842 + useIdx = 1;
1.843 + if( iCol<0 ){
1.844 + zCol = "rowid";
1.845 + }
1.846 + switch( pConstraint->op ){
1.847 + case SQLITE_INDEX_CONSTRAINT_EQ:
1.848 + zOp = "="; break;
1.849 + case SQLITE_INDEX_CONSTRAINT_LT:
1.850 + zOp = "<"; break;
1.851 + case SQLITE_INDEX_CONSTRAINT_GT:
1.852 + zOp = ">"; break;
1.853 + case SQLITE_INDEX_CONSTRAINT_LE:
1.854 + zOp = "<="; break;
1.855 + case SQLITE_INDEX_CONSTRAINT_GE:
1.856 + zOp = ">="; break;
1.857 + case SQLITE_INDEX_CONSTRAINT_MATCH:
1.858 + zOp = "LIKE"; break;
1.859 + }
1.860 + if( zOp[0]=='L' ){
1.861 + zNew = sqlite3_mprintf(" %s %s LIKE (SELECT '%%'||?||'%%')",
1.862 + zSep, zCol);
1.863 + } else {
1.864 + zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zCol, zOp);
1.865 + }
1.866 + string_concat(&zQuery, zNew, 1, &rc);
1.867 +
1.868 + zSep = "AND";
1.869 + pUsage->argvIndex = ++nArg;
1.870 + pUsage->omit = 1;
1.871 + }
1.872 + }
1.873 +
1.874 + /* If there is only one term in the ORDER BY clause, and it is
1.875 + ** on a column that this virtual table has an index for, then consume
1.876 + ** the ORDER BY clause.
1.877 + */
1.878 + if( pIdxInfo->nOrderBy==1 && pVtab->aIndex[pIdxInfo->aOrderBy->iColumn] ){
1.879 + int iCol = pIdxInfo->aOrderBy->iColumn;
1.880 + char *zCol = pVtab->aCol[iCol];
1.881 + char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
1.882 + if( iCol<0 ){
1.883 + zCol = "rowid";
1.884 + }
1.885 + zNew = sqlite3_mprintf(" ORDER BY %s %s", zCol, zDir);
1.886 + string_concat(&zQuery, zNew, 1, &rc);
1.887 + pIdxInfo->orderByConsumed = 1;
1.888 + }
1.889 +
1.890 + appendToEchoModule(pVtab->interp, "xBestIndex");;
1.891 + appendToEchoModule(pVtab->interp, zQuery);
1.892 +
1.893 + if( !zQuery ){
1.894 + return rc;
1.895 + }
1.896 + pIdxInfo->idxNum = hashString(zQuery);
1.897 + pIdxInfo->idxStr = zQuery;
1.898 + pIdxInfo->needToFreeIdxStr = 1;
1.899 + if (useCost) {
1.900 + pIdxInfo->estimatedCost = cost;
1.901 + } else if( useIdx ){
1.902 + /* Approximation of log2(nRow). */
1.903 + for( ii=0; ii<(sizeof(int)*8); ii++ ){
1.904 + if( nRow & (1<<ii) ){
1.905 + pIdxInfo->estimatedCost = (double)ii;
1.906 + }
1.907 + }
1.908 + } else {
1.909 + pIdxInfo->estimatedCost = (double)nRow;
1.910 + }
1.911 + return rc;
1.912 +}
1.913 +
1.914 +/*
1.915 +** The xUpdate method for echo module virtual tables.
1.916 +**
1.917 +** apData[0] apData[1] apData[2..]
1.918 +**
1.919 +** INTEGER DELETE
1.920 +**
1.921 +** INTEGER NULL (nCol args) UPDATE (do not set rowid)
1.922 +** INTEGER INTEGER (nCol args) UPDATE (with SET rowid = <arg1>)
1.923 +**
1.924 +** NULL NULL (nCol args) INSERT INTO (automatic rowid value)
1.925 +** NULL INTEGER (nCol args) INSERT (incl. rowid value)
1.926 +**
1.927 +*/
1.928 +int echoUpdate(
1.929 + sqlite3_vtab *tab,
1.930 + int nData,
1.931 + sqlite3_value **apData,
1.932 + sqlite_int64 *pRowid
1.933 +){
1.934 + echo_vtab *pVtab = (echo_vtab *)tab;
1.935 + sqlite3 *db = pVtab->db;
1.936 + int rc = SQLITE_OK;
1.937 +
1.938 + sqlite3_stmt *pStmt;
1.939 + char *z = 0; /* SQL statement to execute */
1.940 + int bindArgZero = 0; /* True to bind apData[0] to sql var no. nData */
1.941 + int bindArgOne = 0; /* True to bind apData[1] to sql var no. 1 */
1.942 + int i; /* Counter variable used by for loops */
1.943 +
1.944 + assert( nData==pVtab->nCol+2 || nData==1 );
1.945 +
1.946 + /* Ticket #3083 - make sure we always start a transaction prior to
1.947 + ** making any changes to a virtual table */
1.948 + assert( pVtab->inTransaction );
1.949 +
1.950 + if( simulateVtabError(pVtab, "xUpdate") ){
1.951 + return SQLITE_ERROR;
1.952 + }
1.953 +
1.954 + /* If apData[0] is an integer and nData>1 then do an UPDATE */
1.955 + if( nData>1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
1.956 + char *zSep = " SET";
1.957 + z = sqlite3_mprintf("UPDATE %Q", pVtab->zTableName);
1.958 + if( !z ){
1.959 + rc = SQLITE_NOMEM;
1.960 + }
1.961 +
1.962 + bindArgOne = (apData[1] && sqlite3_value_type(apData[1])==SQLITE_INTEGER);
1.963 + bindArgZero = 1;
1.964 +
1.965 + if( bindArgOne ){
1.966 + string_concat(&z, " SET rowid=?1 ", 0, &rc);
1.967 + zSep = ",";
1.968 + }
1.969 + for(i=2; i<nData; i++){
1.970 + if( apData[i]==0 ) continue;
1.971 + string_concat(&z, sqlite3_mprintf(
1.972 + "%s %Q=?%d", zSep, pVtab->aCol[i-2], i), 1, &rc);
1.973 + zSep = ",";
1.974 + }
1.975 + string_concat(&z, sqlite3_mprintf(" WHERE rowid=?%d", nData), 1, &rc);
1.976 + }
1.977 +
1.978 + /* If apData[0] is an integer and nData==1 then do a DELETE */
1.979 + else if( nData==1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
1.980 + z = sqlite3_mprintf("DELETE FROM %Q WHERE rowid = ?1", pVtab->zTableName);
1.981 + if( !z ){
1.982 + rc = SQLITE_NOMEM;
1.983 + }
1.984 + bindArgZero = 1;
1.985 + }
1.986 +
1.987 + /* If the first argument is NULL and there are more than two args, INSERT */
1.988 + else if( nData>2 && sqlite3_value_type(apData[0])==SQLITE_NULL ){
1.989 + int ii;
1.990 + char *zInsert = 0;
1.991 + char *zValues = 0;
1.992 +
1.993 + zInsert = sqlite3_mprintf("INSERT INTO %Q (", pVtab->zTableName);
1.994 + if( !zInsert ){
1.995 + rc = SQLITE_NOMEM;
1.996 + }
1.997 + if( sqlite3_value_type(apData[1])==SQLITE_INTEGER ){
1.998 + bindArgOne = 1;
1.999 + zValues = sqlite3_mprintf("?");
1.1000 + string_concat(&zInsert, "rowid", 0, &rc);
1.1001 + }
1.1002 +
1.1003 + assert((pVtab->nCol+2)==nData);
1.1004 + for(ii=2; ii<nData; ii++){
1.1005 + string_concat(&zInsert,
1.1006 + sqlite3_mprintf("%s%Q", zValues?", ":"", pVtab->aCol[ii-2]), 1, &rc);
1.1007 + string_concat(&zValues,
1.1008 + sqlite3_mprintf("%s?%d", zValues?", ":"", ii), 1, &rc);
1.1009 + }
1.1010 +
1.1011 + string_concat(&z, zInsert, 1, &rc);
1.1012 + string_concat(&z, ") VALUES(", 0, &rc);
1.1013 + string_concat(&z, zValues, 1, &rc);
1.1014 + string_concat(&z, ")", 0, &rc);
1.1015 + }
1.1016 +
1.1017 + /* Anything else is an error */
1.1018 + else{
1.1019 + assert(0);
1.1020 + return SQLITE_ERROR;
1.1021 + }
1.1022 +
1.1023 + if( rc==SQLITE_OK ){
1.1024 + rc = sqlite3_prepare(db, z, -1, &pStmt, 0);
1.1025 + }
1.1026 + assert( rc!=SQLITE_OK || pStmt );
1.1027 + sqlite3_free(z);
1.1028 + if( rc==SQLITE_OK ) {
1.1029 + if( bindArgZero ){
1.1030 + sqlite3_bind_value(pStmt, nData, apData[0]);
1.1031 + }
1.1032 + if( bindArgOne ){
1.1033 + sqlite3_bind_value(pStmt, 1, apData[1]);
1.1034 + }
1.1035 + for(i=2; i<nData && rc==SQLITE_OK; i++){
1.1036 + if( apData[i] ) rc = sqlite3_bind_value(pStmt, i, apData[i]);
1.1037 + }
1.1038 + if( rc==SQLITE_OK ){
1.1039 + sqlite3_step(pStmt);
1.1040 + rc = sqlite3_finalize(pStmt);
1.1041 + }else{
1.1042 + sqlite3_finalize(pStmt);
1.1043 + }
1.1044 + }
1.1045 +
1.1046 + if( pRowid && rc==SQLITE_OK ){
1.1047 + *pRowid = sqlite3_last_insert_rowid(db);
1.1048 + }
1.1049 + if( rc!=SQLITE_OK ){
1.1050 + tab->zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", sqlite3_errmsg(db));
1.1051 + }
1.1052 +
1.1053 + return rc;
1.1054 +}
1.1055 +
1.1056 +/*
1.1057 +** xBegin, xSync, xCommit and xRollback callbacks for echo module
1.1058 +** virtual tables. Do nothing other than add the name of the callback
1.1059 +** to the $::echo_module Tcl variable.
1.1060 +*/
1.1061 +static int echoTransactionCall(sqlite3_vtab *tab, const char *zCall){
1.1062 + char *z;
1.1063 + echo_vtab *pVtab = (echo_vtab *)tab;
1.1064 + z = sqlite3_mprintf("echo(%s)", pVtab->zTableName);
1.1065 + if( z==0 ) return SQLITE_NOMEM;
1.1066 + appendToEchoModule(pVtab->interp, zCall);
1.1067 + appendToEchoModule(pVtab->interp, z);
1.1068 + sqlite3_free(z);
1.1069 + return SQLITE_OK;
1.1070 +}
1.1071 +static int echoBegin(sqlite3_vtab *tab){
1.1072 + int rc;
1.1073 + echo_vtab *pVtab = (echo_vtab *)tab;
1.1074 + Tcl_Interp *interp = pVtab->interp;
1.1075 + const char *zVal;
1.1076 +
1.1077 + /* Ticket #3083 - do not start a transaction if we are already in
1.1078 + ** a transaction */
1.1079 + assert( !pVtab->inTransaction );
1.1080 +
1.1081 + if( simulateVtabError(pVtab, "xBegin") ){
1.1082 + return SQLITE_ERROR;
1.1083 + }
1.1084 +
1.1085 + rc = echoTransactionCall(tab, "xBegin");
1.1086 +
1.1087 + if( rc==SQLITE_OK ){
1.1088 + /* Check if the $::echo_module_begin_fail variable is defined. If it is,
1.1089 + ** and it is set to the name of the real table underlying this virtual
1.1090 + ** echo module table, then cause this xSync operation to fail.
1.1091 + */
1.1092 + zVal = Tcl_GetVar(interp, "echo_module_begin_fail", TCL_GLOBAL_ONLY);
1.1093 + if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
1.1094 + rc = SQLITE_ERROR;
1.1095 + }
1.1096 + }
1.1097 + if( rc==SQLITE_OK ){
1.1098 + pVtab->inTransaction = 1;
1.1099 + }
1.1100 + return rc;
1.1101 +}
1.1102 +static int echoSync(sqlite3_vtab *tab){
1.1103 + int rc;
1.1104 + echo_vtab *pVtab = (echo_vtab *)tab;
1.1105 + Tcl_Interp *interp = pVtab->interp;
1.1106 + const char *zVal;
1.1107 +
1.1108 + /* Ticket #3083 - Only call xSync if we have previously started a
1.1109 + ** transaction */
1.1110 + assert( pVtab->inTransaction );
1.1111 +
1.1112 + if( simulateVtabError(pVtab, "xSync") ){
1.1113 + return SQLITE_ERROR;
1.1114 + }
1.1115 +
1.1116 + rc = echoTransactionCall(tab, "xSync");
1.1117 +
1.1118 + if( rc==SQLITE_OK ){
1.1119 + /* Check if the $::echo_module_sync_fail variable is defined. If it is,
1.1120 + ** and it is set to the name of the real table underlying this virtual
1.1121 + ** echo module table, then cause this xSync operation to fail.
1.1122 + */
1.1123 + zVal = Tcl_GetVar(interp, "echo_module_sync_fail", TCL_GLOBAL_ONLY);
1.1124 + if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
1.1125 + rc = -1;
1.1126 + }
1.1127 + }
1.1128 + return rc;
1.1129 +}
1.1130 +static int echoCommit(sqlite3_vtab *tab){
1.1131 + echo_vtab *pVtab = (echo_vtab*)tab;
1.1132 + int rc;
1.1133 +
1.1134 + /* Ticket #3083 - Only call xCommit if we have previously started
1.1135 + ** a transaction */
1.1136 + assert( pVtab->inTransaction );
1.1137 +
1.1138 + if( simulateVtabError(pVtab, "xCommit") ){
1.1139 + return SQLITE_ERROR;
1.1140 + }
1.1141 +
1.1142 + sqlite3BeginBenignMalloc();
1.1143 + rc = echoTransactionCall(tab, "xCommit");
1.1144 + sqlite3EndBenignMalloc();
1.1145 + pVtab->inTransaction = 0;
1.1146 + return rc;
1.1147 +}
1.1148 +static int echoRollback(sqlite3_vtab *tab){
1.1149 + int rc;
1.1150 + echo_vtab *pVtab = (echo_vtab*)tab;
1.1151 +
1.1152 + /* Ticket #3083 - Only call xRollback if we have previously started
1.1153 + ** a transaction */
1.1154 + assert( pVtab->inTransaction );
1.1155 +
1.1156 + rc = echoTransactionCall(tab, "xRollback");
1.1157 + pVtab->inTransaction = 0;
1.1158 + return rc;
1.1159 +}
1.1160 +
1.1161 +/*
1.1162 +** Implementation of "GLOB" function on the echo module. Pass
1.1163 +** all arguments to the ::echo_glob_overload procedure of TCL
1.1164 +** and return the result of that procedure as a string.
1.1165 +*/
1.1166 +static void overloadedGlobFunction(
1.1167 + sqlite3_context *pContext,
1.1168 + int nArg,
1.1169 + sqlite3_value **apArg
1.1170 +){
1.1171 + Tcl_Interp *interp = sqlite3_user_data(pContext);
1.1172 + Tcl_DString str;
1.1173 + int i;
1.1174 + int rc;
1.1175 + Tcl_DStringInit(&str);
1.1176 + Tcl_DStringAppendElement(&str, "::echo_glob_overload");
1.1177 + for(i=0; i<nArg; i++){
1.1178 + Tcl_DStringAppendElement(&str, (char*)sqlite3_value_text(apArg[i]));
1.1179 + }
1.1180 + rc = Tcl_Eval(interp, Tcl_DStringValue(&str));
1.1181 + Tcl_DStringFree(&str);
1.1182 + if( rc ){
1.1183 + sqlite3_result_error(pContext, Tcl_GetStringResult(interp), -1);
1.1184 + }else{
1.1185 + sqlite3_result_text(pContext, Tcl_GetStringResult(interp),
1.1186 + -1, SQLITE_TRANSIENT);
1.1187 + }
1.1188 + Tcl_ResetResult(interp);
1.1189 +}
1.1190 +
1.1191 +/*
1.1192 +** This is the xFindFunction implementation for the echo module.
1.1193 +** SQLite calls this routine when the first argument of a function
1.1194 +** is a column of an echo virtual table. This routine can optionally
1.1195 +** override the implementation of that function. It will choose to
1.1196 +** do so if the function is named "glob", and a TCL command named
1.1197 +** ::echo_glob_overload exists.
1.1198 +*/
1.1199 +static int echoFindFunction(
1.1200 + sqlite3_vtab *vtab,
1.1201 + int nArg,
1.1202 + const char *zFuncName,
1.1203 + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
1.1204 + void **ppArg
1.1205 +){
1.1206 + echo_vtab *pVtab = (echo_vtab *)vtab;
1.1207 + Tcl_Interp *interp = pVtab->interp;
1.1208 + Tcl_CmdInfo info;
1.1209 + if( strcmp(zFuncName,"glob")!=0 ){
1.1210 + return 0;
1.1211 + }
1.1212 + if( Tcl_GetCommandInfo(interp, "::echo_glob_overload", &info)==0 ){
1.1213 + return 0;
1.1214 + }
1.1215 + *pxFunc = overloadedGlobFunction;
1.1216 + *ppArg = interp;
1.1217 + return 1;
1.1218 +}
1.1219 +
1.1220 +static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
1.1221 + int rc = SQLITE_OK;
1.1222 + echo_vtab *p = (echo_vtab *)vtab;
1.1223 +
1.1224 + if( simulateVtabError(p, "xRename") ){
1.1225 + return SQLITE_ERROR;
1.1226 + }
1.1227 +
1.1228 + if( p->isPattern ){
1.1229 + int nThis = strlen(p->zThis);
1.1230 + char *zSql = sqlite3MPrintf(0, "ALTER TABLE %s RENAME TO %s%s",
1.1231 + p->zTableName, zNewName, &p->zTableName[nThis]
1.1232 + );
1.1233 + rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
1.1234 + sqlite3_free(zSql);
1.1235 + }
1.1236 +
1.1237 + return rc;
1.1238 +}
1.1239 +
1.1240 +/*
1.1241 +** A virtual table module that merely "echos" the contents of another
1.1242 +** table (like an SQL VIEW).
1.1243 +*/
1.1244 +static sqlite3_module echoModule = {
1.1245 + 0, /* iVersion */
1.1246 + echoCreate,
1.1247 + echoConnect,
1.1248 + echoBestIndex,
1.1249 + echoDisconnect,
1.1250 + echoDestroy,
1.1251 + echoOpen, /* xOpen - open a cursor */
1.1252 + echoClose, /* xClose - close a cursor */
1.1253 + echoFilter, /* xFilter - configure scan constraints */
1.1254 + echoNext, /* xNext - advance a cursor */
1.1255 + echoEof, /* xEof */
1.1256 + echoColumn, /* xColumn - read data */
1.1257 + echoRowid, /* xRowid - read data */
1.1258 + echoUpdate, /* xUpdate - write data */
1.1259 + echoBegin, /* xBegin - begin transaction */
1.1260 + echoSync, /* xSync - sync transaction */
1.1261 + echoCommit, /* xCommit - commit transaction */
1.1262 + echoRollback, /* xRollback - rollback transaction */
1.1263 + echoFindFunction, /* xFindFunction - function overloading */
1.1264 + echoRename, /* xRename - rename the table */
1.1265 +};
1.1266 +
1.1267 +/*
1.1268 +** Decode a pointer to an sqlite3 object.
1.1269 +*/
1.1270 +extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
1.1271 +
1.1272 +static void moduleDestroy(void *p){
1.1273 + sqlite3_free(p);
1.1274 +}
1.1275 +
1.1276 +/*
1.1277 +** Register the echo virtual table module.
1.1278 +*/
1.1279 +static int register_echo_module(
1.1280 + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1.1281 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1282 + int objc, /* Number of arguments */
1.1283 + Tcl_Obj *CONST objv[] /* Command arguments */
1.1284 +){
1.1285 + sqlite3 *db;
1.1286 + EchoModule *pMod;
1.1287 + if( objc!=2 ){
1.1288 + Tcl_WrongNumArgs(interp, 1, objv, "DB");
1.1289 + return TCL_ERROR;
1.1290 + }
1.1291 + if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1.1292 + pMod = sqlite3_malloc(sizeof(EchoModule));
1.1293 + pMod->interp = interp;
1.1294 + sqlite3_create_module_v2(db, "echo", &echoModule, (void*)pMod, moduleDestroy);
1.1295 + return TCL_OK;
1.1296 +}
1.1297 +
1.1298 +/*
1.1299 +** Tcl interface to sqlite3_declare_vtab, invoked as follows from Tcl:
1.1300 +**
1.1301 +** sqlite3_declare_vtab DB SQL
1.1302 +*/
1.1303 +static int declare_vtab(
1.1304 + ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
1.1305 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1306 + int objc, /* Number of arguments */
1.1307 + Tcl_Obj *CONST objv[] /* Command arguments */
1.1308 +){
1.1309 + sqlite3 *db;
1.1310 + int rc;
1.1311 + if( objc!=3 ){
1.1312 + Tcl_WrongNumArgs(interp, 1, objv, "DB SQL");
1.1313 + return TCL_ERROR;
1.1314 + }
1.1315 + if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
1.1316 + rc = sqlite3_declare_vtab(db, Tcl_GetString(objv[2]));
1.1317 + if( rc!=SQLITE_OK ){
1.1318 + Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
1.1319 + return TCL_ERROR;
1.1320 + }
1.1321 + return TCL_OK;
1.1322 +}
1.1323 +
1.1324 +#endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
1.1325 +
1.1326 +/*
1.1327 +** Register commands with the TCL interpreter.
1.1328 +*/
1.1329 +int Sqlitetest8_Init(Tcl_Interp *interp){
1.1330 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.1331 + static struct {
1.1332 + char *zName;
1.1333 + Tcl_ObjCmdProc *xProc;
1.1334 + void *clientData;
1.1335 + } aObjCmd[] = {
1.1336 + { "register_echo_module", register_echo_module, 0 },
1.1337 + { "sqlite3_declare_vtab", declare_vtab, 0 },
1.1338 + };
1.1339 + int i;
1.1340 + for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
1.1341 + Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
1.1342 + aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
1.1343 + }
1.1344 +#endif
1.1345 + return TCL_OK;
1.1346 +}