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