Annotation of embedaddon/sqlite3/src/test8.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2006 June 10
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: ** Code for testing the virtual table interfaces. This code
! 13: ** is not included in the SQLite library. It is used for automated
! 14: ** testing of the SQLite library.
! 15: */
! 16: #include "sqliteInt.h"
! 17: #include "tcl.h"
! 18: #include <stdlib.h>
! 19: #include <string.h>
! 20:
! 21: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 22:
! 23: typedef struct echo_vtab echo_vtab;
! 24: typedef struct echo_cursor echo_cursor;
! 25:
! 26: /*
! 27: ** The test module defined in this file uses four global Tcl variables to
! 28: ** commicate with test-scripts:
! 29: **
! 30: ** $::echo_module
! 31: ** $::echo_module_sync_fail
! 32: ** $::echo_module_begin_fail
! 33: ** $::echo_module_cost
! 34: **
! 35: ** The variable ::echo_module is a list. Each time one of the following
! 36: ** methods is called, one or more elements are appended to the list.
! 37: ** This is used for automated testing of virtual table modules.
! 38: **
! 39: ** The ::echo_module_sync_fail variable is set by test scripts and read
! 40: ** by code in this file. If it is set to the name of a real table in the
! 41: ** the database, then all xSync operations on echo virtual tables that
! 42: ** use the named table as a backing store will fail.
! 43: */
! 44:
! 45: /*
! 46: ** Errors can be provoked within the following echo virtual table methods:
! 47: **
! 48: ** xBestIndex xOpen xFilter xNext
! 49: ** xColumn xRowid xUpdate xSync
! 50: ** xBegin xRename
! 51: **
! 52: ** This is done by setting the global tcl variable:
! 53: **
! 54: ** echo_module_fail($method,$tbl)
! 55: **
! 56: ** where $method is set to the name of the virtual table method to fail
! 57: ** (i.e. "xBestIndex") and $tbl is the name of the table being echoed (not
! 58: ** the name of the virtual table, the name of the underlying real table).
! 59: */
! 60:
! 61: /*
! 62: ** An echo virtual-table object.
! 63: **
! 64: ** echo.vtab.aIndex is an array of booleans. The nth entry is true if
! 65: ** the nth column of the real table is the left-most column of an index
! 66: ** (implicit or otherwise). In other words, if SQLite can optimize
! 67: ** a query like "SELECT * FROM real_table WHERE col = ?".
! 68: **
! 69: ** Member variable aCol[] contains copies of the column names of the real
! 70: ** table.
! 71: */
! 72: struct echo_vtab {
! 73: sqlite3_vtab base;
! 74: Tcl_Interp *interp; /* Tcl interpreter containing debug variables */
! 75: sqlite3 *db; /* Database connection */
! 76:
! 77: int isPattern;
! 78: int inTransaction; /* True if within a transaction */
! 79: char *zThis; /* Name of the echo table */
! 80: char *zTableName; /* Name of the real table */
! 81: char *zLogName; /* Name of the log table */
! 82: int nCol; /* Number of columns in the real table */
! 83: int *aIndex; /* Array of size nCol. True if column has an index */
! 84: char **aCol; /* Array of size nCol. Column names */
! 85: };
! 86:
! 87: /* An echo cursor object */
! 88: struct echo_cursor {
! 89: sqlite3_vtab_cursor base;
! 90: sqlite3_stmt *pStmt;
! 91: };
! 92:
! 93: static int simulateVtabError(echo_vtab *p, const char *zMethod){
! 94: const char *zErr;
! 95: char zVarname[128];
! 96: zVarname[127] = '\0';
! 97: sqlite3_snprintf(127, zVarname, "echo_module_fail(%s,%s)", zMethod, p->zTableName);
! 98: zErr = Tcl_GetVar(p->interp, zVarname, TCL_GLOBAL_ONLY);
! 99: if( zErr ){
! 100: p->base.zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", zErr);
! 101: }
! 102: return (zErr!=0);
! 103: }
! 104:
! 105: /*
! 106: ** Convert an SQL-style quoted string into a normal string by removing
! 107: ** the quote characters. The conversion is done in-place. If the
! 108: ** input does not begin with a quote character, then this routine
! 109: ** is a no-op.
! 110: **
! 111: ** Examples:
! 112: **
! 113: ** "abc" becomes abc
! 114: ** 'xyz' becomes xyz
! 115: ** [pqr] becomes pqr
! 116: ** `mno` becomes mno
! 117: */
! 118: static void dequoteString(char *z){
! 119: int quote;
! 120: int i, j;
! 121: if( z==0 ) return;
! 122: quote = z[0];
! 123: switch( quote ){
! 124: case '\'': break;
! 125: case '"': break;
! 126: case '`': break; /* For MySQL compatibility */
! 127: case '[': quote = ']'; break; /* For MS SqlServer compatibility */
! 128: default: return;
! 129: }
! 130: for(i=1, j=0; z[i]; i++){
! 131: if( z[i]==quote ){
! 132: if( z[i+1]==quote ){
! 133: z[j++] = quote;
! 134: i++;
! 135: }else{
! 136: z[j++] = 0;
! 137: break;
! 138: }
! 139: }else{
! 140: z[j++] = z[i];
! 141: }
! 142: }
! 143: }
! 144:
! 145: /*
! 146: ** Retrieve the column names for the table named zTab via database
! 147: ** connection db. SQLITE_OK is returned on success, or an sqlite error
! 148: ** code otherwise.
! 149: **
! 150: ** If successful, the number of columns is written to *pnCol. *paCol is
! 151: ** set to point at sqlite3_malloc()'d space containing the array of
! 152: ** nCol column names. The caller is responsible for calling sqlite3_free
! 153: ** on *paCol.
! 154: */
! 155: static int getColumnNames(
! 156: sqlite3 *db,
! 157: const char *zTab,
! 158: char ***paCol,
! 159: int *pnCol
! 160: ){
! 161: char **aCol = 0;
! 162: char *zSql;
! 163: sqlite3_stmt *pStmt = 0;
! 164: int rc = SQLITE_OK;
! 165: int nCol = 0;
! 166:
! 167: /* Prepare the statement "SELECT * FROM <tbl>". The column names
! 168: ** of the result set of the compiled SELECT will be the same as
! 169: ** the column names of table <tbl>.
! 170: */
! 171: zSql = sqlite3_mprintf("SELECT * FROM %Q", zTab);
! 172: if( !zSql ){
! 173: rc = SQLITE_NOMEM;
! 174: goto out;
! 175: }
! 176: rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
! 177: sqlite3_free(zSql);
! 178:
! 179: if( rc==SQLITE_OK ){
! 180: int ii;
! 181: int nBytes;
! 182: char *zSpace;
! 183: nCol = sqlite3_column_count(pStmt);
! 184:
! 185: /* Figure out how much space to allocate for the array of column names
! 186: ** (including space for the strings themselves). Then allocate it.
! 187: */
! 188: nBytes = sizeof(char *) * nCol;
! 189: for(ii=0; ii<nCol; ii++){
! 190: const char *zName = sqlite3_column_name(pStmt, ii);
! 191: if( !zName ){
! 192: rc = SQLITE_NOMEM;
! 193: goto out;
! 194: }
! 195: nBytes += strlen(zName)+1;
! 196: }
! 197: aCol = (char **)sqlite3MallocZero(nBytes);
! 198: if( !aCol ){
! 199: rc = SQLITE_NOMEM;
! 200: goto out;
! 201: }
! 202:
! 203: /* Copy the column names into the allocated space and set up the
! 204: ** pointers in the aCol[] array.
! 205: */
! 206: zSpace = (char *)(&aCol[nCol]);
! 207: for(ii=0; ii<nCol; ii++){
! 208: aCol[ii] = zSpace;
! 209: zSpace += sprintf(zSpace, "%s", sqlite3_column_name(pStmt, ii));
! 210: zSpace++;
! 211: }
! 212: assert( (zSpace-nBytes)==(char *)aCol );
! 213: }
! 214:
! 215: *paCol = aCol;
! 216: *pnCol = nCol;
! 217:
! 218: out:
! 219: sqlite3_finalize(pStmt);
! 220: return rc;
! 221: }
! 222:
! 223: /*
! 224: ** Parameter zTab is the name of a table in database db with nCol
! 225: ** columns. This function allocates an array of integers nCol in
! 226: ** size and populates it according to any implicit or explicit
! 227: ** indices on table zTab.
! 228: **
! 229: ** If successful, SQLITE_OK is returned and *paIndex set to point
! 230: ** at the allocated array. Otherwise, an error code is returned.
! 231: **
! 232: ** See comments associated with the member variable aIndex above
! 233: ** "struct echo_vtab" for details of the contents of the array.
! 234: */
! 235: static int getIndexArray(
! 236: sqlite3 *db, /* Database connection */
! 237: const char *zTab, /* Name of table in database db */
! 238: int nCol,
! 239: int **paIndex
! 240: ){
! 241: sqlite3_stmt *pStmt = 0;
! 242: int *aIndex = 0;
! 243: int rc;
! 244: char *zSql;
! 245:
! 246: /* Allocate space for the index array */
! 247: aIndex = (int *)sqlite3MallocZero(sizeof(int) * nCol);
! 248: if( !aIndex ){
! 249: rc = SQLITE_NOMEM;
! 250: goto get_index_array_out;
! 251: }
! 252:
! 253: /* Compile an sqlite pragma to loop through all indices on table zTab */
! 254: zSql = sqlite3_mprintf("PRAGMA index_list(%s)", zTab);
! 255: if( !zSql ){
! 256: rc = SQLITE_NOMEM;
! 257: goto get_index_array_out;
! 258: }
! 259: rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
! 260: sqlite3_free(zSql);
! 261:
! 262: /* For each index, figure out the left-most column and set the
! 263: ** corresponding entry in aIndex[] to 1.
! 264: */
! 265: while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
! 266: const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
! 267: sqlite3_stmt *pStmt2 = 0;
! 268: zSql = sqlite3_mprintf("PRAGMA index_info(%s)", zIdx);
! 269: if( !zSql ){
! 270: rc = SQLITE_NOMEM;
! 271: goto get_index_array_out;
! 272: }
! 273: rc = sqlite3_prepare(db, zSql, -1, &pStmt2, 0);
! 274: sqlite3_free(zSql);
! 275: if( pStmt2 && sqlite3_step(pStmt2)==SQLITE_ROW ){
! 276: int cid = sqlite3_column_int(pStmt2, 1);
! 277: assert( cid>=0 && cid<nCol );
! 278: aIndex[cid] = 1;
! 279: }
! 280: if( pStmt2 ){
! 281: rc = sqlite3_finalize(pStmt2);
! 282: }
! 283: if( rc!=SQLITE_OK ){
! 284: goto get_index_array_out;
! 285: }
! 286: }
! 287:
! 288:
! 289: get_index_array_out:
! 290: if( pStmt ){
! 291: int rc2 = sqlite3_finalize(pStmt);
! 292: if( rc==SQLITE_OK ){
! 293: rc = rc2;
! 294: }
! 295: }
! 296: if( rc!=SQLITE_OK ){
! 297: sqlite3_free(aIndex);
! 298: aIndex = 0;
! 299: }
! 300: *paIndex = aIndex;
! 301: return rc;
! 302: }
! 303:
! 304: /*
! 305: ** Global Tcl variable $echo_module is a list. This routine appends
! 306: ** the string element zArg to that list in interpreter interp.
! 307: */
! 308: static void appendToEchoModule(Tcl_Interp *interp, const char *zArg){
! 309: int flags = (TCL_APPEND_VALUE | TCL_LIST_ELEMENT | TCL_GLOBAL_ONLY);
! 310: Tcl_SetVar(interp, "echo_module", (zArg?zArg:""), flags);
! 311: }
! 312:
! 313: /*
! 314: ** This function is called from within the echo-modules xCreate and
! 315: ** xConnect methods. The argc and argv arguments are copies of those
! 316: ** passed to the calling method. This function is responsible for
! 317: ** calling sqlite3_declare_vtab() to declare the schema of the virtual
! 318: ** table being created or connected.
! 319: **
! 320: ** If the constructor was passed just one argument, i.e.:
! 321: **
! 322: ** CREATE TABLE t1 AS echo(t2);
! 323: **
! 324: ** Then t2 is assumed to be the name of a *real* database table. The
! 325: ** schema of the virtual table is declared by passing a copy of the
! 326: ** CREATE TABLE statement for the real table to sqlite3_declare_vtab().
! 327: ** Hence, the virtual table should have exactly the same column names and
! 328: ** types as the real table.
! 329: */
! 330: static int echoDeclareVtab(
! 331: echo_vtab *pVtab,
! 332: sqlite3 *db
! 333: ){
! 334: int rc = SQLITE_OK;
! 335:
! 336: if( pVtab->zTableName ){
! 337: sqlite3_stmt *pStmt = 0;
! 338: rc = sqlite3_prepare(db,
! 339: "SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
! 340: -1, &pStmt, 0);
! 341: if( rc==SQLITE_OK ){
! 342: sqlite3_bind_text(pStmt, 1, pVtab->zTableName, -1, 0);
! 343: if( sqlite3_step(pStmt)==SQLITE_ROW ){
! 344: int rc2;
! 345: const char *zCreateTable = (const char *)sqlite3_column_text(pStmt, 0);
! 346: rc = sqlite3_declare_vtab(db, zCreateTable);
! 347: rc2 = sqlite3_finalize(pStmt);
! 348: if( rc==SQLITE_OK ){
! 349: rc = rc2;
! 350: }
! 351: } else {
! 352: rc = sqlite3_finalize(pStmt);
! 353: if( rc==SQLITE_OK ){
! 354: rc = SQLITE_ERROR;
! 355: }
! 356: }
! 357: if( rc==SQLITE_OK ){
! 358: rc = getColumnNames(db, pVtab->zTableName, &pVtab->aCol, &pVtab->nCol);
! 359: }
! 360: if( rc==SQLITE_OK ){
! 361: rc = getIndexArray(db, pVtab->zTableName, pVtab->nCol, &pVtab->aIndex);
! 362: }
! 363: }
! 364: }
! 365:
! 366: return rc;
! 367: }
! 368:
! 369: /*
! 370: ** This function frees all runtime structures associated with the virtual
! 371: ** table pVtab.
! 372: */
! 373: static int echoDestructor(sqlite3_vtab *pVtab){
! 374: echo_vtab *p = (echo_vtab*)pVtab;
! 375: sqlite3_free(p->aIndex);
! 376: sqlite3_free(p->aCol);
! 377: sqlite3_free(p->zThis);
! 378: sqlite3_free(p->zTableName);
! 379: sqlite3_free(p->zLogName);
! 380: sqlite3_free(p);
! 381: return 0;
! 382: }
! 383:
! 384: typedef struct EchoModule EchoModule;
! 385: struct EchoModule {
! 386: Tcl_Interp *interp;
! 387: };
! 388:
! 389: /*
! 390: ** This function is called to do the work of the xConnect() method -
! 391: ** to allocate the required in-memory structures for a newly connected
! 392: ** virtual table.
! 393: */
! 394: static int echoConstructor(
! 395: sqlite3 *db,
! 396: void *pAux,
! 397: int argc, const char *const*argv,
! 398: sqlite3_vtab **ppVtab,
! 399: char **pzErr
! 400: ){
! 401: int rc;
! 402: int i;
! 403: echo_vtab *pVtab;
! 404:
! 405: /* Allocate the sqlite3_vtab/echo_vtab structure itself */
! 406: pVtab = sqlite3MallocZero( sizeof(*pVtab) );
! 407: if( !pVtab ){
! 408: return SQLITE_NOMEM;
! 409: }
! 410: pVtab->interp = ((EchoModule *)pAux)->interp;
! 411: pVtab->db = db;
! 412:
! 413: /* Allocate echo_vtab.zThis */
! 414: pVtab->zThis = sqlite3_mprintf("%s", argv[2]);
! 415: if( !pVtab->zThis ){
! 416: echoDestructor((sqlite3_vtab *)pVtab);
! 417: return SQLITE_NOMEM;
! 418: }
! 419:
! 420: /* Allocate echo_vtab.zTableName */
! 421: if( argc>3 ){
! 422: pVtab->zTableName = sqlite3_mprintf("%s", argv[3]);
! 423: dequoteString(pVtab->zTableName);
! 424: if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){
! 425: char *z = sqlite3_mprintf("%s%s", argv[2], &(pVtab->zTableName[1]));
! 426: sqlite3_free(pVtab->zTableName);
! 427: pVtab->zTableName = z;
! 428: pVtab->isPattern = 1;
! 429: }
! 430: if( !pVtab->zTableName ){
! 431: echoDestructor((sqlite3_vtab *)pVtab);
! 432: return SQLITE_NOMEM;
! 433: }
! 434: }
! 435:
! 436: /* Log the arguments to this function to Tcl var ::echo_module */
! 437: for(i=0; i<argc; i++){
! 438: appendToEchoModule(pVtab->interp, argv[i]);
! 439: }
! 440:
! 441: /* Invoke sqlite3_declare_vtab and set up other members of the echo_vtab
! 442: ** structure. If an error occurs, delete the sqlite3_vtab structure and
! 443: ** return an error code.
! 444: */
! 445: rc = echoDeclareVtab(pVtab, db);
! 446: if( rc!=SQLITE_OK ){
! 447: echoDestructor((sqlite3_vtab *)pVtab);
! 448: return rc;
! 449: }
! 450:
! 451: /* Success. Set *ppVtab and return */
! 452: *ppVtab = &pVtab->base;
! 453: return SQLITE_OK;
! 454: }
! 455:
! 456: /*
! 457: ** Echo virtual table module xCreate method.
! 458: */
! 459: static int echoCreate(
! 460: sqlite3 *db,
! 461: void *pAux,
! 462: int argc, const char *const*argv,
! 463: sqlite3_vtab **ppVtab,
! 464: char **pzErr
! 465: ){
! 466: int rc = SQLITE_OK;
! 467: appendToEchoModule(((EchoModule *)pAux)->interp, "xCreate");
! 468: rc = echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
! 469:
! 470: /* If there were two arguments passed to the module at the SQL level
! 471: ** (i.e. "CREATE VIRTUAL TABLE tbl USING echo(arg1, arg2)"), then
! 472: ** the second argument is used as a table name. Attempt to create
! 473: ** such a table with a single column, "logmsg". This table will
! 474: ** be used to log calls to the xUpdate method. It will be deleted
! 475: ** when the virtual table is DROPed.
! 476: **
! 477: ** Note: The main point of this is to test that we can drop tables
! 478: ** from within an xDestroy method call.
! 479: */
! 480: if( rc==SQLITE_OK && argc==5 ){
! 481: char *zSql;
! 482: echo_vtab *pVtab = *(echo_vtab **)ppVtab;
! 483: pVtab->zLogName = sqlite3_mprintf("%s", argv[4]);
! 484: zSql = sqlite3_mprintf("CREATE TABLE %Q(logmsg)", pVtab->zLogName);
! 485: rc = sqlite3_exec(db, zSql, 0, 0, 0);
! 486: sqlite3_free(zSql);
! 487: if( rc!=SQLITE_OK ){
! 488: *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
! 489: }
! 490: }
! 491:
! 492: if( *ppVtab && rc!=SQLITE_OK ){
! 493: echoDestructor(*ppVtab);
! 494: *ppVtab = 0;
! 495: }
! 496:
! 497: if( rc==SQLITE_OK ){
! 498: (*(echo_vtab**)ppVtab)->inTransaction = 1;
! 499: }
! 500:
! 501: return rc;
! 502: }
! 503:
! 504: /*
! 505: ** Echo virtual table module xConnect method.
! 506: */
! 507: static int echoConnect(
! 508: sqlite3 *db,
! 509: void *pAux,
! 510: int argc, const char *const*argv,
! 511: sqlite3_vtab **ppVtab,
! 512: char **pzErr
! 513: ){
! 514: appendToEchoModule(((EchoModule *)pAux)->interp, "xConnect");
! 515: return echoConstructor(db, pAux, argc, argv, ppVtab, pzErr);
! 516: }
! 517:
! 518: /*
! 519: ** Echo virtual table module xDisconnect method.
! 520: */
! 521: static int echoDisconnect(sqlite3_vtab *pVtab){
! 522: appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDisconnect");
! 523: return echoDestructor(pVtab);
! 524: }
! 525:
! 526: /*
! 527: ** Echo virtual table module xDestroy method.
! 528: */
! 529: static int echoDestroy(sqlite3_vtab *pVtab){
! 530: int rc = SQLITE_OK;
! 531: echo_vtab *p = (echo_vtab *)pVtab;
! 532: appendToEchoModule(((echo_vtab *)pVtab)->interp, "xDestroy");
! 533:
! 534: /* Drop the "log" table, if one exists (see echoCreate() for details) */
! 535: if( p && p->zLogName ){
! 536: char *zSql;
! 537: zSql = sqlite3_mprintf("DROP TABLE %Q", p->zLogName);
! 538: rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
! 539: sqlite3_free(zSql);
! 540: }
! 541:
! 542: if( rc==SQLITE_OK ){
! 543: rc = echoDestructor(pVtab);
! 544: }
! 545: return rc;
! 546: }
! 547:
! 548: /*
! 549: ** Echo virtual table module xOpen method.
! 550: */
! 551: static int echoOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){
! 552: echo_cursor *pCur;
! 553: if( simulateVtabError((echo_vtab *)pVTab, "xOpen") ){
! 554: return SQLITE_ERROR;
! 555: }
! 556: pCur = sqlite3MallocZero(sizeof(echo_cursor));
! 557: *ppCursor = (sqlite3_vtab_cursor *)pCur;
! 558: return (pCur ? SQLITE_OK : SQLITE_NOMEM);
! 559: }
! 560:
! 561: /*
! 562: ** Echo virtual table module xClose method.
! 563: */
! 564: static int echoClose(sqlite3_vtab_cursor *cur){
! 565: int rc;
! 566: echo_cursor *pCur = (echo_cursor *)cur;
! 567: sqlite3_stmt *pStmt = pCur->pStmt;
! 568: pCur->pStmt = 0;
! 569: sqlite3_free(pCur);
! 570: rc = sqlite3_finalize(pStmt);
! 571: return rc;
! 572: }
! 573:
! 574: /*
! 575: ** Return non-zero if the cursor does not currently point to a valid record
! 576: ** (i.e if the scan has finished), or zero otherwise.
! 577: */
! 578: static int echoEof(sqlite3_vtab_cursor *cur){
! 579: return (((echo_cursor *)cur)->pStmt ? 0 : 1);
! 580: }
! 581:
! 582: /*
! 583: ** Echo virtual table module xNext method.
! 584: */
! 585: static int echoNext(sqlite3_vtab_cursor *cur){
! 586: int rc = SQLITE_OK;
! 587: echo_cursor *pCur = (echo_cursor *)cur;
! 588:
! 589: if( simulateVtabError((echo_vtab *)(cur->pVtab), "xNext") ){
! 590: return SQLITE_ERROR;
! 591: }
! 592:
! 593: if( pCur->pStmt ){
! 594: rc = sqlite3_step(pCur->pStmt);
! 595: if( rc==SQLITE_ROW ){
! 596: rc = SQLITE_OK;
! 597: }else{
! 598: rc = sqlite3_finalize(pCur->pStmt);
! 599: pCur->pStmt = 0;
! 600: }
! 601: }
! 602:
! 603: return rc;
! 604: }
! 605:
! 606: /*
! 607: ** Echo virtual table module xColumn method.
! 608: */
! 609: static int echoColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){
! 610: int iCol = i + 1;
! 611: sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
! 612:
! 613: if( simulateVtabError((echo_vtab *)(cur->pVtab), "xColumn") ){
! 614: return SQLITE_ERROR;
! 615: }
! 616:
! 617: if( !pStmt ){
! 618: sqlite3_result_null(ctx);
! 619: }else{
! 620: assert( sqlite3_data_count(pStmt)>iCol );
! 621: sqlite3_result_value(ctx, sqlite3_column_value(pStmt, iCol));
! 622: }
! 623: return SQLITE_OK;
! 624: }
! 625:
! 626: /*
! 627: ** Echo virtual table module xRowid method.
! 628: */
! 629: static int echoRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){
! 630: sqlite3_stmt *pStmt = ((echo_cursor *)cur)->pStmt;
! 631:
! 632: if( simulateVtabError((echo_vtab *)(cur->pVtab), "xRowid") ){
! 633: return SQLITE_ERROR;
! 634: }
! 635:
! 636: *pRowid = sqlite3_column_int64(pStmt, 0);
! 637: return SQLITE_OK;
! 638: }
! 639:
! 640: /*
! 641: ** Compute a simple hash of the null terminated string zString.
! 642: **
! 643: ** This module uses only sqlite3_index_info.idxStr, not
! 644: ** sqlite3_index_info.idxNum. So to test idxNum, when idxStr is set
! 645: ** in echoBestIndex(), idxNum is set to the corresponding hash value.
! 646: ** In echoFilter(), code assert()s that the supplied idxNum value is
! 647: ** indeed the hash of the supplied idxStr.
! 648: */
! 649: static int hashString(const char *zString){
! 650: int val = 0;
! 651: int ii;
! 652: for(ii=0; zString[ii]; ii++){
! 653: val = (val << 3) + (int)zString[ii];
! 654: }
! 655: return val;
! 656: }
! 657:
! 658: /*
! 659: ** Echo virtual table module xFilter method.
! 660: */
! 661: static int echoFilter(
! 662: sqlite3_vtab_cursor *pVtabCursor,
! 663: int idxNum, const char *idxStr,
! 664: int argc, sqlite3_value **argv
! 665: ){
! 666: int rc;
! 667: int i;
! 668:
! 669: echo_cursor *pCur = (echo_cursor *)pVtabCursor;
! 670: echo_vtab *pVtab = (echo_vtab *)pVtabCursor->pVtab;
! 671: sqlite3 *db = pVtab->db;
! 672:
! 673: if( simulateVtabError(pVtab, "xFilter") ){
! 674: return SQLITE_ERROR;
! 675: }
! 676:
! 677: /* Check that idxNum matches idxStr */
! 678: assert( idxNum==hashString(idxStr) );
! 679:
! 680: /* Log arguments to the ::echo_module Tcl variable */
! 681: appendToEchoModule(pVtab->interp, "xFilter");
! 682: appendToEchoModule(pVtab->interp, idxStr);
! 683: for(i=0; i<argc; i++){
! 684: appendToEchoModule(pVtab->interp, (const char*)sqlite3_value_text(argv[i]));
! 685: }
! 686:
! 687: sqlite3_finalize(pCur->pStmt);
! 688: pCur->pStmt = 0;
! 689:
! 690: /* Prepare the SQL statement created by echoBestIndex and bind the
! 691: ** runtime parameters passed to this function to it.
! 692: */
! 693: rc = sqlite3_prepare(db, idxStr, -1, &pCur->pStmt, 0);
! 694: assert( pCur->pStmt || rc!=SQLITE_OK );
! 695: for(i=0; rc==SQLITE_OK && i<argc; i++){
! 696: rc = sqlite3_bind_value(pCur->pStmt, i+1, argv[i]);
! 697: }
! 698:
! 699: /* If everything was successful, advance to the first row of the scan */
! 700: if( rc==SQLITE_OK ){
! 701: rc = echoNext(pVtabCursor);
! 702: }
! 703:
! 704: return rc;
! 705: }
! 706:
! 707:
! 708: /*
! 709: ** A helper function used by echoUpdate() and echoBestIndex() for
! 710: ** manipulating strings in concert with the sqlite3_mprintf() function.
! 711: **
! 712: ** Parameter pzStr points to a pointer to a string allocated with
! 713: ** sqlite3_mprintf. The second parameter, zAppend, points to another
! 714: ** string. The two strings are concatenated together and *pzStr
! 715: ** set to point at the result. The initial buffer pointed to by *pzStr
! 716: ** is deallocated via sqlite3_free().
! 717: **
! 718: ** If the third argument, doFree, is true, then sqlite3_free() is
! 719: ** also called to free the buffer pointed to by zAppend.
! 720: */
! 721: static void string_concat(char **pzStr, char *zAppend, int doFree, int *pRc){
! 722: char *zIn = *pzStr;
! 723: if( !zAppend && doFree && *pRc==SQLITE_OK ){
! 724: *pRc = SQLITE_NOMEM;
! 725: }
! 726: if( *pRc!=SQLITE_OK ){
! 727: sqlite3_free(zIn);
! 728: zIn = 0;
! 729: }else{
! 730: if( zIn ){
! 731: char *zTemp = zIn;
! 732: zIn = sqlite3_mprintf("%s%s", zIn, zAppend);
! 733: sqlite3_free(zTemp);
! 734: }else{
! 735: zIn = sqlite3_mprintf("%s", zAppend);
! 736: }
! 737: if( !zIn ){
! 738: *pRc = SQLITE_NOMEM;
! 739: }
! 740: }
! 741: *pzStr = zIn;
! 742: if( doFree ){
! 743: sqlite3_free(zAppend);
! 744: }
! 745: }
! 746:
! 747: /*
! 748: ** The echo module implements the subset of query constraints and sort
! 749: ** orders that may take advantage of SQLite indices on the underlying
! 750: ** real table. For example, if the real table is declared as:
! 751: **
! 752: ** CREATE TABLE real(a, b, c);
! 753: ** CREATE INDEX real_index ON real(b);
! 754: **
! 755: ** then the echo module handles WHERE or ORDER BY clauses that refer
! 756: ** to the column "b", but not "a" or "c". If a multi-column index is
! 757: ** present, only its left most column is considered.
! 758: **
! 759: ** This xBestIndex method encodes the proposed search strategy as
! 760: ** an SQL query on the real table underlying the virtual echo module
! 761: ** table and stores the query in sqlite3_index_info.idxStr. The SQL
! 762: ** statement is of the form:
! 763: **
! 764: ** SELECT rowid, * FROM <real-table> ?<where-clause>? ?<order-by-clause>?
! 765: **
! 766: ** where the <where-clause> and <order-by-clause> are determined
! 767: ** by the contents of the structure pointed to by the pIdxInfo argument.
! 768: */
! 769: static int echoBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
! 770: int ii;
! 771: char *zQuery = 0;
! 772: char *zNew;
! 773: int nArg = 0;
! 774: const char *zSep = "WHERE";
! 775: echo_vtab *pVtab = (echo_vtab *)tab;
! 776: sqlite3_stmt *pStmt = 0;
! 777: Tcl_Interp *interp = pVtab->interp;
! 778:
! 779: int nRow;
! 780: int useIdx = 0;
! 781: int rc = SQLITE_OK;
! 782: int useCost = 0;
! 783: double cost;
! 784: int isIgnoreUsable = 0;
! 785: if( Tcl_GetVar(interp, "echo_module_ignore_usable", TCL_GLOBAL_ONLY) ){
! 786: isIgnoreUsable = 1;
! 787: }
! 788:
! 789: if( simulateVtabError(pVtab, "xBestIndex") ){
! 790: return SQLITE_ERROR;
! 791: }
! 792:
! 793: /* Determine the number of rows in the table and store this value in local
! 794: ** variable nRow. The 'estimated-cost' of the scan will be the number of
! 795: ** rows in the table for a linear scan, or the log (base 2) of the
! 796: ** number of rows if the proposed scan uses an index.
! 797: */
! 798: if( Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY) ){
! 799: cost = atof(Tcl_GetVar(interp, "echo_module_cost", TCL_GLOBAL_ONLY));
! 800: useCost = 1;
! 801: } else {
! 802: zQuery = sqlite3_mprintf("SELECT count(*) FROM %Q", pVtab->zTableName);
! 803: if( !zQuery ){
! 804: return SQLITE_NOMEM;
! 805: }
! 806: rc = sqlite3_prepare(pVtab->db, zQuery, -1, &pStmt, 0);
! 807: sqlite3_free(zQuery);
! 808: if( rc!=SQLITE_OK ){
! 809: return rc;
! 810: }
! 811: sqlite3_step(pStmt);
! 812: nRow = sqlite3_column_int(pStmt, 0);
! 813: rc = sqlite3_finalize(pStmt);
! 814: if( rc!=SQLITE_OK ){
! 815: return rc;
! 816: }
! 817: }
! 818:
! 819: zQuery = sqlite3_mprintf("SELECT rowid, * FROM %Q", pVtab->zTableName);
! 820: if( !zQuery ){
! 821: return SQLITE_NOMEM;
! 822: }
! 823: for(ii=0; ii<pIdxInfo->nConstraint; ii++){
! 824: const struct sqlite3_index_constraint *pConstraint;
! 825: struct sqlite3_index_constraint_usage *pUsage;
! 826: int iCol;
! 827:
! 828: pConstraint = &pIdxInfo->aConstraint[ii];
! 829: pUsage = &pIdxInfo->aConstraintUsage[ii];
! 830:
! 831: if( !isIgnoreUsable && !pConstraint->usable ) continue;
! 832:
! 833: iCol = pConstraint->iColumn;
! 834: if( pVtab->aIndex[iCol] || iCol<0 ){
! 835: char *zCol = pVtab->aCol[iCol];
! 836: char *zOp = 0;
! 837: useIdx = 1;
! 838: if( iCol<0 ){
! 839: zCol = "rowid";
! 840: }
! 841: switch( pConstraint->op ){
! 842: case SQLITE_INDEX_CONSTRAINT_EQ:
! 843: zOp = "="; break;
! 844: case SQLITE_INDEX_CONSTRAINT_LT:
! 845: zOp = "<"; break;
! 846: case SQLITE_INDEX_CONSTRAINT_GT:
! 847: zOp = ">"; break;
! 848: case SQLITE_INDEX_CONSTRAINT_LE:
! 849: zOp = "<="; break;
! 850: case SQLITE_INDEX_CONSTRAINT_GE:
! 851: zOp = ">="; break;
! 852: case SQLITE_INDEX_CONSTRAINT_MATCH:
! 853: zOp = "LIKE"; break;
! 854: }
! 855: if( zOp[0]=='L' ){
! 856: zNew = sqlite3_mprintf(" %s %s LIKE (SELECT '%%'||?||'%%')",
! 857: zSep, zCol);
! 858: } else {
! 859: zNew = sqlite3_mprintf(" %s %s %s ?", zSep, zCol, zOp);
! 860: }
! 861: string_concat(&zQuery, zNew, 1, &rc);
! 862:
! 863: zSep = "AND";
! 864: pUsage->argvIndex = ++nArg;
! 865: pUsage->omit = 1;
! 866: }
! 867: }
! 868:
! 869: /* If there is only one term in the ORDER BY clause, and it is
! 870: ** on a column that this virtual table has an index for, then consume
! 871: ** the ORDER BY clause.
! 872: */
! 873: if( pIdxInfo->nOrderBy==1 && pVtab->aIndex[pIdxInfo->aOrderBy->iColumn] ){
! 874: int iCol = pIdxInfo->aOrderBy->iColumn;
! 875: char *zCol = pVtab->aCol[iCol];
! 876: char *zDir = pIdxInfo->aOrderBy->desc?"DESC":"ASC";
! 877: if( iCol<0 ){
! 878: zCol = "rowid";
! 879: }
! 880: zNew = sqlite3_mprintf(" ORDER BY %s %s", zCol, zDir);
! 881: string_concat(&zQuery, zNew, 1, &rc);
! 882: pIdxInfo->orderByConsumed = 1;
! 883: }
! 884:
! 885: appendToEchoModule(pVtab->interp, "xBestIndex");;
! 886: appendToEchoModule(pVtab->interp, zQuery);
! 887:
! 888: if( !zQuery ){
! 889: return rc;
! 890: }
! 891: pIdxInfo->idxNum = hashString(zQuery);
! 892: pIdxInfo->idxStr = zQuery;
! 893: pIdxInfo->needToFreeIdxStr = 1;
! 894: if( useCost ){
! 895: pIdxInfo->estimatedCost = cost;
! 896: }else if( useIdx ){
! 897: /* Approximation of log2(nRow). */
! 898: for( ii=0; ii<(sizeof(int)*8); ii++ ){
! 899: if( nRow & (1<<ii) ){
! 900: pIdxInfo->estimatedCost = (double)ii;
! 901: }
! 902: }
! 903: }else{
! 904: pIdxInfo->estimatedCost = (double)nRow;
! 905: }
! 906: return rc;
! 907: }
! 908:
! 909: /*
! 910: ** The xUpdate method for echo module virtual tables.
! 911: **
! 912: ** apData[0] apData[1] apData[2..]
! 913: **
! 914: ** INTEGER DELETE
! 915: **
! 916: ** INTEGER NULL (nCol args) UPDATE (do not set rowid)
! 917: ** INTEGER INTEGER (nCol args) UPDATE (with SET rowid = <arg1>)
! 918: **
! 919: ** NULL NULL (nCol args) INSERT INTO (automatic rowid value)
! 920: ** NULL INTEGER (nCol args) INSERT (incl. rowid value)
! 921: **
! 922: */
! 923: int echoUpdate(
! 924: sqlite3_vtab *tab,
! 925: int nData,
! 926: sqlite3_value **apData,
! 927: sqlite_int64 *pRowid
! 928: ){
! 929: echo_vtab *pVtab = (echo_vtab *)tab;
! 930: sqlite3 *db = pVtab->db;
! 931: int rc = SQLITE_OK;
! 932:
! 933: sqlite3_stmt *pStmt;
! 934: char *z = 0; /* SQL statement to execute */
! 935: int bindArgZero = 0; /* True to bind apData[0] to sql var no. nData */
! 936: int bindArgOne = 0; /* True to bind apData[1] to sql var no. 1 */
! 937: int i; /* Counter variable used by for loops */
! 938:
! 939: assert( nData==pVtab->nCol+2 || nData==1 );
! 940:
! 941: /* Ticket #3083 - make sure we always start a transaction prior to
! 942: ** making any changes to a virtual table */
! 943: assert( pVtab->inTransaction );
! 944:
! 945: if( simulateVtabError(pVtab, "xUpdate") ){
! 946: return SQLITE_ERROR;
! 947: }
! 948:
! 949: /* If apData[0] is an integer and nData>1 then do an UPDATE */
! 950: if( nData>1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
! 951: char *zSep = " SET";
! 952: z = sqlite3_mprintf("UPDATE %Q", pVtab->zTableName);
! 953: if( !z ){
! 954: rc = SQLITE_NOMEM;
! 955: }
! 956:
! 957: bindArgOne = (apData[1] && sqlite3_value_type(apData[1])==SQLITE_INTEGER);
! 958: bindArgZero = 1;
! 959:
! 960: if( bindArgOne ){
! 961: string_concat(&z, " SET rowid=?1 ", 0, &rc);
! 962: zSep = ",";
! 963: }
! 964: for(i=2; i<nData; i++){
! 965: if( apData[i]==0 ) continue;
! 966: string_concat(&z, sqlite3_mprintf(
! 967: "%s %Q=?%d", zSep, pVtab->aCol[i-2], i), 1, &rc);
! 968: zSep = ",";
! 969: }
! 970: string_concat(&z, sqlite3_mprintf(" WHERE rowid=?%d", nData), 1, &rc);
! 971: }
! 972:
! 973: /* If apData[0] is an integer and nData==1 then do a DELETE */
! 974: else if( nData==1 && sqlite3_value_type(apData[0])==SQLITE_INTEGER ){
! 975: z = sqlite3_mprintf("DELETE FROM %Q WHERE rowid = ?1", pVtab->zTableName);
! 976: if( !z ){
! 977: rc = SQLITE_NOMEM;
! 978: }
! 979: bindArgZero = 1;
! 980: }
! 981:
! 982: /* If the first argument is NULL and there are more than two args, INSERT */
! 983: else if( nData>2 && sqlite3_value_type(apData[0])==SQLITE_NULL ){
! 984: int ii;
! 985: char *zInsert = 0;
! 986: char *zValues = 0;
! 987:
! 988: zInsert = sqlite3_mprintf("INSERT INTO %Q (", pVtab->zTableName);
! 989: if( !zInsert ){
! 990: rc = SQLITE_NOMEM;
! 991: }
! 992: if( sqlite3_value_type(apData[1])==SQLITE_INTEGER ){
! 993: bindArgOne = 1;
! 994: zValues = sqlite3_mprintf("?");
! 995: string_concat(&zInsert, "rowid", 0, &rc);
! 996: }
! 997:
! 998: assert((pVtab->nCol+2)==nData);
! 999: for(ii=2; ii<nData; ii++){
! 1000: string_concat(&zInsert,
! 1001: sqlite3_mprintf("%s%Q", zValues?", ":"", pVtab->aCol[ii-2]), 1, &rc);
! 1002: string_concat(&zValues,
! 1003: sqlite3_mprintf("%s?%d", zValues?", ":"", ii), 1, &rc);
! 1004: }
! 1005:
! 1006: string_concat(&z, zInsert, 1, &rc);
! 1007: string_concat(&z, ") VALUES(", 0, &rc);
! 1008: string_concat(&z, zValues, 1, &rc);
! 1009: string_concat(&z, ")", 0, &rc);
! 1010: }
! 1011:
! 1012: /* Anything else is an error */
! 1013: else{
! 1014: assert(0);
! 1015: return SQLITE_ERROR;
! 1016: }
! 1017:
! 1018: if( rc==SQLITE_OK ){
! 1019: rc = sqlite3_prepare(db, z, -1, &pStmt, 0);
! 1020: }
! 1021: assert( rc!=SQLITE_OK || pStmt );
! 1022: sqlite3_free(z);
! 1023: if( rc==SQLITE_OK ) {
! 1024: if( bindArgZero ){
! 1025: sqlite3_bind_value(pStmt, nData, apData[0]);
! 1026: }
! 1027: if( bindArgOne ){
! 1028: sqlite3_bind_value(pStmt, 1, apData[1]);
! 1029: }
! 1030: for(i=2; i<nData && rc==SQLITE_OK; i++){
! 1031: if( apData[i] ) rc = sqlite3_bind_value(pStmt, i, apData[i]);
! 1032: }
! 1033: if( rc==SQLITE_OK ){
! 1034: sqlite3_step(pStmt);
! 1035: rc = sqlite3_finalize(pStmt);
! 1036: }else{
! 1037: sqlite3_finalize(pStmt);
! 1038: }
! 1039: }
! 1040:
! 1041: if( pRowid && rc==SQLITE_OK ){
! 1042: *pRowid = sqlite3_last_insert_rowid(db);
! 1043: }
! 1044: if( rc!=SQLITE_OK ){
! 1045: tab->zErrMsg = sqlite3_mprintf("echo-vtab-error: %s", sqlite3_errmsg(db));
! 1046: }
! 1047:
! 1048: return rc;
! 1049: }
! 1050:
! 1051: /*
! 1052: ** xBegin, xSync, xCommit and xRollback callbacks for echo module
! 1053: ** virtual tables. Do nothing other than add the name of the callback
! 1054: ** to the $::echo_module Tcl variable.
! 1055: */
! 1056: static int echoTransactionCall(sqlite3_vtab *tab, const char *zCall){
! 1057: char *z;
! 1058: echo_vtab *pVtab = (echo_vtab *)tab;
! 1059: z = sqlite3_mprintf("echo(%s)", pVtab->zTableName);
! 1060: if( z==0 ) return SQLITE_NOMEM;
! 1061: appendToEchoModule(pVtab->interp, zCall);
! 1062: appendToEchoModule(pVtab->interp, z);
! 1063: sqlite3_free(z);
! 1064: return SQLITE_OK;
! 1065: }
! 1066: static int echoBegin(sqlite3_vtab *tab){
! 1067: int rc;
! 1068: echo_vtab *pVtab = (echo_vtab *)tab;
! 1069: Tcl_Interp *interp = pVtab->interp;
! 1070: const char *zVal;
! 1071:
! 1072: /* Ticket #3083 - do not start a transaction if we are already in
! 1073: ** a transaction */
! 1074: assert( !pVtab->inTransaction );
! 1075:
! 1076: if( simulateVtabError(pVtab, "xBegin") ){
! 1077: return SQLITE_ERROR;
! 1078: }
! 1079:
! 1080: rc = echoTransactionCall(tab, "xBegin");
! 1081:
! 1082: if( rc==SQLITE_OK ){
! 1083: /* Check if the $::echo_module_begin_fail variable is defined. If it is,
! 1084: ** and it is set to the name of the real table underlying this virtual
! 1085: ** echo module table, then cause this xSync operation to fail.
! 1086: */
! 1087: zVal = Tcl_GetVar(interp, "echo_module_begin_fail", TCL_GLOBAL_ONLY);
! 1088: if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
! 1089: rc = SQLITE_ERROR;
! 1090: }
! 1091: }
! 1092: if( rc==SQLITE_OK ){
! 1093: pVtab->inTransaction = 1;
! 1094: }
! 1095: return rc;
! 1096: }
! 1097: static int echoSync(sqlite3_vtab *tab){
! 1098: int rc;
! 1099: echo_vtab *pVtab = (echo_vtab *)tab;
! 1100: Tcl_Interp *interp = pVtab->interp;
! 1101: const char *zVal;
! 1102:
! 1103: /* Ticket #3083 - Only call xSync if we have previously started a
! 1104: ** transaction */
! 1105: assert( pVtab->inTransaction );
! 1106:
! 1107: if( simulateVtabError(pVtab, "xSync") ){
! 1108: return SQLITE_ERROR;
! 1109: }
! 1110:
! 1111: rc = echoTransactionCall(tab, "xSync");
! 1112:
! 1113: if( rc==SQLITE_OK ){
! 1114: /* Check if the $::echo_module_sync_fail variable is defined. If it is,
! 1115: ** and it is set to the name of the real table underlying this virtual
! 1116: ** echo module table, then cause this xSync operation to fail.
! 1117: */
! 1118: zVal = Tcl_GetVar(interp, "echo_module_sync_fail", TCL_GLOBAL_ONLY);
! 1119: if( zVal && 0==strcmp(zVal, pVtab->zTableName) ){
! 1120: rc = -1;
! 1121: }
! 1122: }
! 1123: return rc;
! 1124: }
! 1125: static int echoCommit(sqlite3_vtab *tab){
! 1126: echo_vtab *pVtab = (echo_vtab*)tab;
! 1127: int rc;
! 1128:
! 1129: /* Ticket #3083 - Only call xCommit if we have previously started
! 1130: ** a transaction */
! 1131: assert( pVtab->inTransaction );
! 1132:
! 1133: if( simulateVtabError(pVtab, "xCommit") ){
! 1134: return SQLITE_ERROR;
! 1135: }
! 1136:
! 1137: sqlite3BeginBenignMalloc();
! 1138: rc = echoTransactionCall(tab, "xCommit");
! 1139: sqlite3EndBenignMalloc();
! 1140: pVtab->inTransaction = 0;
! 1141: return rc;
! 1142: }
! 1143: static int echoRollback(sqlite3_vtab *tab){
! 1144: int rc;
! 1145: echo_vtab *pVtab = (echo_vtab*)tab;
! 1146:
! 1147: /* Ticket #3083 - Only call xRollback if we have previously started
! 1148: ** a transaction */
! 1149: assert( pVtab->inTransaction );
! 1150:
! 1151: rc = echoTransactionCall(tab, "xRollback");
! 1152: pVtab->inTransaction = 0;
! 1153: return rc;
! 1154: }
! 1155:
! 1156: /*
! 1157: ** Implementation of "GLOB" function on the echo module. Pass
! 1158: ** all arguments to the ::echo_glob_overload procedure of TCL
! 1159: ** and return the result of that procedure as a string.
! 1160: */
! 1161: static void overloadedGlobFunction(
! 1162: sqlite3_context *pContext,
! 1163: int nArg,
! 1164: sqlite3_value **apArg
! 1165: ){
! 1166: Tcl_Interp *interp = sqlite3_user_data(pContext);
! 1167: Tcl_DString str;
! 1168: int i;
! 1169: int rc;
! 1170: Tcl_DStringInit(&str);
! 1171: Tcl_DStringAppendElement(&str, "::echo_glob_overload");
! 1172: for(i=0; i<nArg; i++){
! 1173: Tcl_DStringAppendElement(&str, (char*)sqlite3_value_text(apArg[i]));
! 1174: }
! 1175: rc = Tcl_Eval(interp, Tcl_DStringValue(&str));
! 1176: Tcl_DStringFree(&str);
! 1177: if( rc ){
! 1178: sqlite3_result_error(pContext, Tcl_GetStringResult(interp), -1);
! 1179: }else{
! 1180: sqlite3_result_text(pContext, Tcl_GetStringResult(interp),
! 1181: -1, SQLITE_TRANSIENT);
! 1182: }
! 1183: Tcl_ResetResult(interp);
! 1184: }
! 1185:
! 1186: /*
! 1187: ** This is the xFindFunction implementation for the echo module.
! 1188: ** SQLite calls this routine when the first argument of a function
! 1189: ** is a column of an echo virtual table. This routine can optionally
! 1190: ** override the implementation of that function. It will choose to
! 1191: ** do so if the function is named "glob", and a TCL command named
! 1192: ** ::echo_glob_overload exists.
! 1193: */
! 1194: static int echoFindFunction(
! 1195: sqlite3_vtab *vtab,
! 1196: int nArg,
! 1197: const char *zFuncName,
! 1198: void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
! 1199: void **ppArg
! 1200: ){
! 1201: echo_vtab *pVtab = (echo_vtab *)vtab;
! 1202: Tcl_Interp *interp = pVtab->interp;
! 1203: Tcl_CmdInfo info;
! 1204: if( strcmp(zFuncName,"glob")!=0 ){
! 1205: return 0;
! 1206: }
! 1207: if( Tcl_GetCommandInfo(interp, "::echo_glob_overload", &info)==0 ){
! 1208: return 0;
! 1209: }
! 1210: *pxFunc = overloadedGlobFunction;
! 1211: *ppArg = interp;
! 1212: return 1;
! 1213: }
! 1214:
! 1215: static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
! 1216: int rc = SQLITE_OK;
! 1217: echo_vtab *p = (echo_vtab *)vtab;
! 1218:
! 1219: if( simulateVtabError(p, "xRename") ){
! 1220: return SQLITE_ERROR;
! 1221: }
! 1222:
! 1223: if( p->isPattern ){
! 1224: int nThis = strlen(p->zThis);
! 1225: char *zSql = sqlite3_mprintf("ALTER TABLE %s RENAME TO %s%s",
! 1226: p->zTableName, zNewName, &p->zTableName[nThis]
! 1227: );
! 1228: rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
! 1229: sqlite3_free(zSql);
! 1230: }
! 1231:
! 1232: return rc;
! 1233: }
! 1234:
! 1235: static int echoSavepoint(sqlite3_vtab *pVTab, int iSavepoint){
! 1236: assert( pVTab );
! 1237: return SQLITE_OK;
! 1238: }
! 1239:
! 1240: static int echoRelease(sqlite3_vtab *pVTab, int iSavepoint){
! 1241: assert( pVTab );
! 1242: return SQLITE_OK;
! 1243: }
! 1244:
! 1245: static int echoRollbackTo(sqlite3_vtab *pVTab, int iSavepoint){
! 1246: assert( pVTab );
! 1247: return SQLITE_OK;
! 1248: }
! 1249:
! 1250: /*
! 1251: ** A virtual table module that merely "echos" the contents of another
! 1252: ** table (like an SQL VIEW).
! 1253: */
! 1254: static sqlite3_module echoModule = {
! 1255: 1, /* iVersion */
! 1256: echoCreate,
! 1257: echoConnect,
! 1258: echoBestIndex,
! 1259: echoDisconnect,
! 1260: echoDestroy,
! 1261: echoOpen, /* xOpen - open a cursor */
! 1262: echoClose, /* xClose - close a cursor */
! 1263: echoFilter, /* xFilter - configure scan constraints */
! 1264: echoNext, /* xNext - advance a cursor */
! 1265: echoEof, /* xEof */
! 1266: echoColumn, /* xColumn - read data */
! 1267: echoRowid, /* xRowid - read data */
! 1268: echoUpdate, /* xUpdate - write data */
! 1269: echoBegin, /* xBegin - begin transaction */
! 1270: echoSync, /* xSync - sync transaction */
! 1271: echoCommit, /* xCommit - commit transaction */
! 1272: echoRollback, /* xRollback - rollback transaction */
! 1273: echoFindFunction, /* xFindFunction - function overloading */
! 1274: echoRename /* xRename - rename the table */
! 1275: };
! 1276:
! 1277: static sqlite3_module echoModuleV2 = {
! 1278: 2, /* iVersion */
! 1279: echoCreate,
! 1280: echoConnect,
! 1281: echoBestIndex,
! 1282: echoDisconnect,
! 1283: echoDestroy,
! 1284: echoOpen, /* xOpen - open a cursor */
! 1285: echoClose, /* xClose - close a cursor */
! 1286: echoFilter, /* xFilter - configure scan constraints */
! 1287: echoNext, /* xNext - advance a cursor */
! 1288: echoEof, /* xEof */
! 1289: echoColumn, /* xColumn - read data */
! 1290: echoRowid, /* xRowid - read data */
! 1291: echoUpdate, /* xUpdate - write data */
! 1292: echoBegin, /* xBegin - begin transaction */
! 1293: echoSync, /* xSync - sync transaction */
! 1294: echoCommit, /* xCommit - commit transaction */
! 1295: echoRollback, /* xRollback - rollback transaction */
! 1296: echoFindFunction, /* xFindFunction - function overloading */
! 1297: echoRename, /* xRename - rename the table */
! 1298: echoSavepoint,
! 1299: echoRelease,
! 1300: echoRollbackTo
! 1301: };
! 1302:
! 1303: /*
! 1304: ** Decode a pointer to an sqlite3 object.
! 1305: */
! 1306: extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
! 1307:
! 1308: static void moduleDestroy(void *p){
! 1309: sqlite3_free(p);
! 1310: }
! 1311:
! 1312: /*
! 1313: ** Register the echo virtual table module.
! 1314: */
! 1315: static int register_echo_module(
! 1316: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 1317: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1318: int objc, /* Number of arguments */
! 1319: Tcl_Obj *CONST objv[] /* Command arguments */
! 1320: ){
! 1321: sqlite3 *db;
! 1322: EchoModule *pMod;
! 1323: if( objc!=2 ){
! 1324: Tcl_WrongNumArgs(interp, 1, objv, "DB");
! 1325: return TCL_ERROR;
! 1326: }
! 1327: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1328:
! 1329: /* Virtual table module "echo" */
! 1330: pMod = sqlite3_malloc(sizeof(EchoModule));
! 1331: pMod->interp = interp;
! 1332: sqlite3_create_module_v2(db, "echo", &echoModule, (void*)pMod, moduleDestroy);
! 1333:
! 1334: /* Virtual table module "echo_v2" */
! 1335: pMod = sqlite3_malloc(sizeof(EchoModule));
! 1336: pMod->interp = interp;
! 1337: sqlite3_create_module_v2(db, "echo_v2",
! 1338: &echoModuleV2, (void*)pMod, moduleDestroy
! 1339: );
! 1340: return TCL_OK;
! 1341: }
! 1342:
! 1343: /*
! 1344: ** Tcl interface to sqlite3_declare_vtab, invoked as follows from Tcl:
! 1345: **
! 1346: ** sqlite3_declare_vtab DB SQL
! 1347: */
! 1348: static int declare_vtab(
! 1349: ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
! 1350: Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
! 1351: int objc, /* Number of arguments */
! 1352: Tcl_Obj *CONST objv[] /* Command arguments */
! 1353: ){
! 1354: sqlite3 *db;
! 1355: int rc;
! 1356: if( objc!=3 ){
! 1357: Tcl_WrongNumArgs(interp, 1, objv, "DB SQL");
! 1358: return TCL_ERROR;
! 1359: }
! 1360: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
! 1361: rc = sqlite3_declare_vtab(db, Tcl_GetString(objv[2]));
! 1362: if( rc!=SQLITE_OK ){
! 1363: Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);
! 1364: return TCL_ERROR;
! 1365: }
! 1366: return TCL_OK;
! 1367: }
! 1368:
! 1369: #endif /* ifndef SQLITE_OMIT_VIRTUALTABLE */
! 1370:
! 1371: /*
! 1372: ** Register commands with the TCL interpreter.
! 1373: */
! 1374: int Sqlitetest8_Init(Tcl_Interp *interp){
! 1375: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 1376: static struct {
! 1377: char *zName;
! 1378: Tcl_ObjCmdProc *xProc;
! 1379: void *clientData;
! 1380: } aObjCmd[] = {
! 1381: { "register_echo_module", register_echo_module, 0 },
! 1382: { "sqlite3_declare_vtab", declare_vtab, 0 },
! 1383: };
! 1384: int i;
! 1385: for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
! 1386: Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
! 1387: aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
! 1388: }
! 1389: #endif
! 1390: return TCL_OK;
! 1391: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test8.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src