1 /* 2 ** 2016-03-01 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 xBestIndex method and the query 13 ** planner. 14 */ 15 16 17 /* 18 ** INSTRUCTIONS 19 ** 20 ** This module exports a single tcl command - [register_tcl_module]. When 21 ** invoked, it registers a special virtual table module with a database 22 ** connection. 23 ** 24 ** The virtual table is currently read-only. And always returns zero rows. 25 ** It is created with a single argument - the name of a Tcl command - as 26 ** follows: 27 ** 28 ** CREATE VIRTUAL TABLE x1 USING tcl(tcl_command); 29 ** 30 ** The command [tcl_command] is invoked when the table is first created (or 31 ** connected), when the xBestIndex() method is invoked and when the xFilter() 32 ** method is called. When it is created (or connected), it is invoked as 33 ** follows: 34 ** 35 ** tcl_command xConnect 36 ** 37 ** In this case the return value of the script is passed to the 38 ** sqlite3_declare_vtab() function to create the virtual table schema. 39 ** 40 ** When the xBestIndex() method is called by SQLite, the Tcl command is 41 ** invoked as: 42 ** 43 ** tcl_command xBestIndex CONSTRAINTS ORDERBY MASK 44 ** 45 ** where CONSTRAINTS is a tcl representation of the aConstraints[] array, 46 ** ORDERBY is a representation of the contents of the aOrderBy[] array and 47 ** MASK is a copy of sqlite3_index_info.colUsed. For example if the virtual 48 ** table is declared as: 49 ** 50 ** CREATE TABLE x1(a, b, c) 51 ** 52 ** and the query is: 53 ** 54 ** SELECT * FROM x1 WHERE a=? AND c<? ORDER BY b, c; 55 ** 56 ** then the Tcl command is: 57 ** 58 ** tcl_command xBestIndex \ 59 ** {{op eq column 0 usable 1} {op lt column 2 usable 1}} \ 60 ** {{column 1 desc 0} {column 2 desc 0}} \ 61 ** 7 62 ** 63 ** The return value of the script is a list of key-value pairs used to 64 ** populate the output fields of the sqlite3_index_info structure. Possible 65 ** keys and the usage of the accompanying values are: 66 ** 67 ** "orderby" (value of orderByConsumed flag) 68 ** "cost" (value of estimatedCost field) 69 ** "rows" (value of estimatedRows field) 70 ** "use" (index of used constraint in aConstraint[]) 71 ** "omit" (like "use", but also sets omit flag) 72 ** "idxnum" (value of idxNum field) 73 ** "idxstr" (value of idxStr field) 74 ** 75 ** Refer to code below for further details. 76 ** 77 ** When SQLite calls the xFilter() method, this module invokes the following 78 ** Tcl script: 79 ** 80 ** tcl_command xFilter IDXNUM IDXSTR ARGLIST 81 ** 82 ** IDXNUM and IDXSTR are the values of the idxNum and idxStr parameters 83 ** passed to xFilter. ARGLIST is a Tcl list containing each of the arguments 84 ** passed to xFilter in text form. 85 ** 86 ** As with xBestIndex(), the return value of the script is interpreted as a 87 ** list of key-value pairs. There is currently only one key defined - "sql". 88 ** The value must be the full text of an SQL statement that returns the data 89 ** for the current scan. The leftmost column returned by the SELECT is assumed 90 ** to contain the rowid. Other columns must follow, in order from left to 91 ** right. 92 */ 93 94 95 #include "sqliteInt.h" 96 #if defined(INCLUDE_SQLITE_TCL_H) 97 # include "sqlite_tcl.h" 98 #else 99 # include "tcl.h" 100 #endif 101 102 #ifndef SQLITE_OMIT_VIRTUALTABLE 103 104 typedef struct tcl_vtab tcl_vtab; 105 typedef struct tcl_cursor tcl_cursor; 106 107 /* 108 ** A fs virtual-table object 109 */ 110 struct tcl_vtab { 111 sqlite3_vtab base; 112 Tcl_Interp *interp; 113 Tcl_Obj *pCmd; 114 sqlite3 *db; 115 }; 116 117 /* A tcl cursor object */ 118 struct tcl_cursor { 119 sqlite3_vtab_cursor base; 120 sqlite3_stmt *pStmt; /* Read data from here */ 121 }; 122 123 /* 124 ** Dequote string z in place. 125 */ 126 static void tclDequote(char *z){ 127 char q = z[0]; 128 129 /* Set stack variable q to the close-quote character */ 130 if( q=='[' || q=='\'' || q=='"' || q=='`' ){ 131 int iIn = 1; 132 int iOut = 0; 133 if( q=='[' ) q = ']'; 134 135 while( ALWAYS(z[iIn]) ){ 136 if( z[iIn]==q ){ 137 if( z[iIn+1]!=q ){ 138 /* Character iIn was the close quote. */ 139 iIn++; 140 break; 141 }else{ 142 /* Character iIn and iIn+1 form an escaped quote character. Skip 143 ** the input cursor past both and copy a single quote character 144 ** to the output buffer. */ 145 iIn += 2; 146 z[iOut++] = q; 147 } 148 }else{ 149 z[iOut++] = z[iIn++]; 150 } 151 } 152 153 z[iOut] = '\0'; 154 } 155 } 156 157 /* 158 ** This function is the implementation of both the xConnect and xCreate 159 ** methods of the fs virtual table. 160 ** 161 ** The argv[] array contains the following: 162 ** 163 ** argv[0] -> module name ("fs") 164 ** argv[1] -> database name 165 ** argv[2] -> table name 166 ** argv[...] -> other module argument fields. 167 */ 168 static int tclConnect( 169 sqlite3 *db, 170 void *pAux, 171 int argc, const char *const*argv, 172 sqlite3_vtab **ppVtab, 173 char **pzErr 174 ){ 175 Tcl_Interp *interp = (Tcl_Interp*)pAux; 176 tcl_vtab *pTab = 0; 177 char *zCmd = 0; 178 Tcl_Obj *pScript = 0; 179 int rc = SQLITE_OK; 180 181 if( argc!=4 ){ 182 *pzErr = sqlite3_mprintf("wrong number of arguments"); 183 return SQLITE_ERROR; 184 } 185 186 zCmd = sqlite3_malloc64(strlen(argv[3])+1); 187 pTab = (tcl_vtab*)sqlite3_malloc64(sizeof(tcl_vtab)); 188 if( zCmd && pTab ){ 189 memcpy(zCmd, argv[3], strlen(argv[3])+1); 190 tclDequote(zCmd); 191 memset(pTab, 0, sizeof(tcl_vtab)); 192 193 pTab->pCmd = Tcl_NewStringObj(zCmd, -1); 194 pTab->interp = interp; 195 pTab->db = db; 196 Tcl_IncrRefCount(pTab->pCmd); 197 198 pScript = Tcl_DuplicateObj(pTab->pCmd); 199 Tcl_IncrRefCount(pScript); 200 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xConnect", -1)); 201 202 rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL); 203 if( rc!=TCL_OK ){ 204 *pzErr = sqlite3_mprintf("%s", Tcl_GetStringResult(interp)); 205 rc = SQLITE_ERROR; 206 }else{ 207 rc = sqlite3_declare_vtab(db, Tcl_GetStringResult(interp)); 208 } 209 210 if( rc!=SQLITE_OK ){ 211 sqlite3_free(pTab); 212 pTab = 0; 213 } 214 }else{ 215 rc = SQLITE_NOMEM; 216 } 217 218 sqlite3_free(zCmd); 219 *ppVtab = &pTab->base; 220 return rc; 221 } 222 223 /* The xDisconnect and xDestroy methods are also the same */ 224 static int tclDisconnect(sqlite3_vtab *pVtab){ 225 tcl_vtab *pTab = (tcl_vtab*)pVtab; 226 Tcl_DecrRefCount(pTab->pCmd); 227 sqlite3_free(pTab); 228 return SQLITE_OK; 229 } 230 231 /* 232 ** Open a new tcl cursor. 233 */ 234 static int tclOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){ 235 tcl_cursor *pCur; 236 pCur = sqlite3_malloc(sizeof(tcl_cursor)); 237 if( pCur==0 ) return SQLITE_NOMEM; 238 memset(pCur, 0, sizeof(tcl_cursor)); 239 *ppCursor = &pCur->base; 240 return SQLITE_OK; 241 } 242 243 /* 244 ** Close a tcl cursor. 245 */ 246 static int tclClose(sqlite3_vtab_cursor *cur){ 247 tcl_cursor *pCur = (tcl_cursor *)cur; 248 if( pCur ){ 249 sqlite3_finalize(pCur->pStmt); 250 sqlite3_free(pCur); 251 } 252 return SQLITE_OK; 253 } 254 255 static int tclNext(sqlite3_vtab_cursor *pVtabCursor){ 256 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor; 257 if( pCsr->pStmt ){ 258 tcl_vtab *pTab = (tcl_vtab*)(pVtabCursor->pVtab); 259 int rc = sqlite3_step(pCsr->pStmt); 260 if( rc!=SQLITE_ROW ){ 261 const char *zErr; 262 rc = sqlite3_finalize(pCsr->pStmt); 263 pCsr->pStmt = 0; 264 if( rc!=SQLITE_OK ){ 265 zErr = sqlite3_errmsg(pTab->db); 266 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr); 267 } 268 } 269 } 270 return SQLITE_OK; 271 } 272 273 static int tclFilter( 274 sqlite3_vtab_cursor *pVtabCursor, 275 int idxNum, const char *idxStr, 276 int argc, sqlite3_value **argv 277 ){ 278 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor; 279 tcl_vtab *pTab = (tcl_vtab*)(pVtabCursor->pVtab); 280 Tcl_Interp *interp = pTab->interp; 281 Tcl_Obj *pScript; 282 Tcl_Obj *pArg; 283 int ii; 284 int rc; 285 286 pScript = Tcl_DuplicateObj(pTab->pCmd); 287 Tcl_IncrRefCount(pScript); 288 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xFilter", -1)); 289 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewIntObj(idxNum)); 290 if( idxStr ){ 291 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj(idxStr, -1)); 292 }else{ 293 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("", -1)); 294 } 295 296 pArg = Tcl_NewObj(); 297 Tcl_IncrRefCount(pArg); 298 for(ii=0; ii<argc; ii++){ 299 const char *zVal = (const char*)sqlite3_value_text(argv[ii]); 300 Tcl_Obj *pVal; 301 if( zVal==0 ){ 302 pVal = Tcl_NewObj(); 303 }else{ 304 pVal = Tcl_NewStringObj(zVal, -1); 305 } 306 Tcl_ListObjAppendElement(interp, pArg, pVal); 307 } 308 Tcl_ListObjAppendElement(interp, pScript, pArg); 309 Tcl_DecrRefCount(pArg); 310 311 rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL); 312 if( rc!=TCL_OK ){ 313 const char *zErr = Tcl_GetStringResult(interp); 314 rc = SQLITE_ERROR; 315 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr); 316 }else{ 317 /* Analyze the scripts return value. The return value should be a tcl 318 ** list object with an even number of elements. The first element of each 319 ** pair must be one of: 320 ** 321 ** "sql" (SQL statement to return data) 322 */ 323 Tcl_Obj *pRes = Tcl_GetObjResult(interp); 324 Tcl_Obj **apElem = 0; 325 int nElem; 326 rc = Tcl_ListObjGetElements(interp, pRes, &nElem, &apElem); 327 if( rc!=TCL_OK ){ 328 const char *zErr = Tcl_GetStringResult(interp); 329 rc = SQLITE_ERROR; 330 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr); 331 }else{ 332 for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){ 333 const char *zCmd = Tcl_GetString(apElem[ii]); 334 Tcl_Obj *p = apElem[ii+1]; 335 if( sqlite3_stricmp("sql", zCmd)==0 ){ 336 const char *zSql = Tcl_GetString(p); 337 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0); 338 if( rc!=SQLITE_OK ){ 339 const char *zErr = sqlite3_errmsg(pTab->db); 340 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zErr); 341 } 342 }else{ 343 rc = SQLITE_ERROR; 344 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zCmd); 345 } 346 } 347 } 348 } 349 350 if( rc==SQLITE_OK ){ 351 rc = tclNext(pVtabCursor); 352 } 353 return rc; 354 } 355 356 static int tclColumn( 357 sqlite3_vtab_cursor *pVtabCursor, 358 sqlite3_context *ctx, 359 int i 360 ){ 361 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor; 362 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pStmt, i+1)); 363 return SQLITE_OK; 364 } 365 366 static int tclRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){ 367 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor; 368 *pRowid = sqlite3_column_int64(pCsr->pStmt, 0); 369 return SQLITE_OK; 370 } 371 372 static int tclEof(sqlite3_vtab_cursor *pVtabCursor){ 373 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor; 374 return (pCsr->pStmt==0); 375 } 376 377 static int tclBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){ 378 tcl_vtab *pTab = (tcl_vtab*)tab; 379 Tcl_Interp *interp = pTab->interp; 380 Tcl_Obj *pArg; 381 Tcl_Obj *pScript; 382 int ii; 383 int rc = SQLITE_OK; 384 385 pScript = Tcl_DuplicateObj(pTab->pCmd); 386 Tcl_IncrRefCount(pScript); 387 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xBestIndex", -1)); 388 389 pArg = Tcl_NewObj(); 390 Tcl_IncrRefCount(pArg); 391 for(ii=0; ii<pIdxInfo->nConstraint; ii++){ 392 struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii]; 393 Tcl_Obj *pElem = Tcl_NewObj(); 394 const char *zOp = "?"; 395 396 Tcl_IncrRefCount(pElem); 397 398 switch( pCons->op ){ 399 case SQLITE_INDEX_CONSTRAINT_EQ: 400 zOp = "eq"; break; 401 case SQLITE_INDEX_CONSTRAINT_GT: 402 zOp = "gt"; break; 403 case SQLITE_INDEX_CONSTRAINT_LE: 404 zOp = "le"; break; 405 case SQLITE_INDEX_CONSTRAINT_LT: 406 zOp = "lt"; break; 407 case SQLITE_INDEX_CONSTRAINT_GE: 408 zOp = "ge"; break; 409 case SQLITE_INDEX_CONSTRAINT_MATCH: 410 zOp = "match"; break; 411 case SQLITE_INDEX_CONSTRAINT_LIKE: 412 zOp = "like"; break; 413 case SQLITE_INDEX_CONSTRAINT_GLOB: 414 zOp = "glob"; break; 415 case SQLITE_INDEX_CONSTRAINT_REGEXP: 416 zOp = "regexp"; break; 417 case SQLITE_INDEX_CONSTRAINT_NE: 418 zOp = "ne"; break; 419 case SQLITE_INDEX_CONSTRAINT_ISNOT: 420 zOp = "isnot"; break; 421 case SQLITE_INDEX_CONSTRAINT_ISNOTNULL: 422 zOp = "isnotnull"; break; 423 case SQLITE_INDEX_CONSTRAINT_ISNULL: 424 zOp = "isnull"; break; 425 case SQLITE_INDEX_CONSTRAINT_IS: 426 zOp = "is"; break; 427 } 428 429 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("op", -1)); 430 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj(zOp, -1)); 431 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("column", -1)); 432 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->iColumn)); 433 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("usable", -1)); 434 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->usable)); 435 436 Tcl_ListObjAppendElement(0, pArg, pElem); 437 Tcl_DecrRefCount(pElem); 438 } 439 440 Tcl_ListObjAppendElement(0, pScript, pArg); 441 Tcl_DecrRefCount(pArg); 442 443 pArg = Tcl_NewObj(); 444 Tcl_IncrRefCount(pArg); 445 for(ii=0; ii<pIdxInfo->nOrderBy; ii++){ 446 struct sqlite3_index_orderby const *pOrder = &pIdxInfo->aOrderBy[ii]; 447 Tcl_Obj *pElem = Tcl_NewObj(); 448 Tcl_IncrRefCount(pElem); 449 450 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("column", -1)); 451 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->iColumn)); 452 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("desc", -1)); 453 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->desc)); 454 455 Tcl_ListObjAppendElement(0, pArg, pElem); 456 Tcl_DecrRefCount(pElem); 457 } 458 459 Tcl_ListObjAppendElement(0, pScript, pArg); 460 Tcl_DecrRefCount(pArg); 461 462 Tcl_ListObjAppendElement(0, pScript, Tcl_NewWideIntObj(pIdxInfo->colUsed)); 463 464 rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL); 465 Tcl_DecrRefCount(pScript); 466 if( rc!=TCL_OK ){ 467 const char *zErr = Tcl_GetStringResult(interp); 468 rc = SQLITE_ERROR; 469 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr); 470 }else{ 471 /* Analyze the scripts return value. The return value should be a tcl 472 ** list object with an even number of elements. The first element of each 473 ** pair must be one of: 474 ** 475 ** "orderby" (value of orderByConsumed flag) 476 ** "cost" (value of estimatedCost field) 477 ** "rows" (value of estimatedRows field) 478 ** "use" (index of used constraint in aConstraint[]) 479 ** "idxnum" (value of idxNum field) 480 ** "idxstr" (value of idxStr field) 481 ** "omit" (index of omitted constraint in aConstraint[]) 482 */ 483 Tcl_Obj *pRes = Tcl_GetObjResult(interp); 484 Tcl_Obj **apElem = 0; 485 int nElem; 486 rc = Tcl_ListObjGetElements(interp, pRes, &nElem, &apElem); 487 if( rc!=TCL_OK ){ 488 const char *zErr = Tcl_GetStringResult(interp); 489 rc = SQLITE_ERROR; 490 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr); 491 }else{ 492 int iArgv = 1; 493 for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){ 494 const char *zCmd = Tcl_GetString(apElem[ii]); 495 Tcl_Obj *p = apElem[ii+1]; 496 if( sqlite3_stricmp("cost", zCmd)==0 ){ 497 rc = Tcl_GetDoubleFromObj(interp, p, &pIdxInfo->estimatedCost); 498 }else 499 if( sqlite3_stricmp("orderby", zCmd)==0 ){ 500 rc = Tcl_GetIntFromObj(interp, p, &pIdxInfo->orderByConsumed); 501 }else 502 if( sqlite3_stricmp("idxnum", zCmd)==0 ){ 503 rc = Tcl_GetIntFromObj(interp, p, &pIdxInfo->idxNum); 504 }else 505 if( sqlite3_stricmp("idxstr", zCmd)==0 ){ 506 sqlite3_free(pIdxInfo->idxStr); 507 pIdxInfo->idxStr = sqlite3_mprintf("%s", Tcl_GetString(p)); 508 pIdxInfo->needToFreeIdxStr = 1; 509 }else 510 if( sqlite3_stricmp("rows", zCmd)==0 ){ 511 Tcl_WideInt x = 0; 512 rc = Tcl_GetWideIntFromObj(interp, p, &x); 513 pIdxInfo->estimatedRows = (tRowcnt)x; 514 }else 515 if( sqlite3_stricmp("use", zCmd)==0 516 || sqlite3_stricmp("omit", zCmd)==0 517 ){ 518 int iCons; 519 rc = Tcl_GetIntFromObj(interp, p, &iCons); 520 if( rc==SQLITE_OK ){ 521 if( iCons<0 || iCons>=pIdxInfo->nConstraint ){ 522 rc = SQLITE_ERROR; 523 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %d", iCons); 524 }else{ 525 int bOmit = (zCmd[0]=='o' || zCmd[0]=='O'); 526 pIdxInfo->aConstraintUsage[iCons].argvIndex = iArgv++; 527 pIdxInfo->aConstraintUsage[iCons].omit = bOmit; 528 } 529 } 530 }else{ 531 rc = SQLITE_ERROR; 532 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zCmd); 533 } 534 if( rc!=SQLITE_OK && pTab->base.zErrMsg==0 ){ 535 const char *zErr = Tcl_GetStringResult(interp); 536 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr); 537 } 538 } 539 } 540 } 541 542 return rc; 543 } 544 545 /* 546 ** A virtual table module that provides read-only access to a 547 ** Tcl global variable namespace. 548 */ 549 static sqlite3_module tclModule = { 550 0, /* iVersion */ 551 tclConnect, 552 tclConnect, 553 tclBestIndex, 554 tclDisconnect, 555 tclDisconnect, 556 tclOpen, /* xOpen - open a cursor */ 557 tclClose, /* xClose - close a cursor */ 558 tclFilter, /* xFilter - configure scan constraints */ 559 tclNext, /* xNext - advance a cursor */ 560 tclEof, /* xEof - check for end of scan */ 561 tclColumn, /* xColumn - read data */ 562 tclRowid, /* xRowid - read data */ 563 0, /* xUpdate */ 564 0, /* xBegin */ 565 0, /* xSync */ 566 0, /* xCommit */ 567 0, /* xRollback */ 568 0, /* xFindMethod */ 569 0, /* xRename */ 570 }; 571 572 /* 573 ** Decode a pointer to an sqlite3 object. 574 */ 575 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb); 576 577 /* 578 ** Register the echo virtual table module. 579 */ 580 static int SQLITE_TCLAPI register_tcl_module( 581 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */ 582 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */ 583 int objc, /* Number of arguments */ 584 Tcl_Obj *CONST objv[] /* Command arguments */ 585 ){ 586 sqlite3 *db; 587 if( objc!=2 ){ 588 Tcl_WrongNumArgs(interp, 1, objv, "DB"); 589 return TCL_ERROR; 590 } 591 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 592 #ifndef SQLITE_OMIT_VIRTUALTABLE 593 sqlite3_create_module(db, "tcl", &tclModule, (void *)interp); 594 #endif 595 return TCL_OK; 596 } 597 598 #endif 599 600 601 /* 602 ** Register commands with the TCL interpreter. 603 */ 604 int Sqlitetesttcl_Init(Tcl_Interp *interp){ 605 #ifndef SQLITE_OMIT_VIRTUALTABLE 606 static struct { 607 char *zName; 608 Tcl_ObjCmdProc *xProc; 609 void *clientData; 610 } aObjCmd[] = { 611 { "register_tcl_module", register_tcl_module, 0 }, 612 }; 613 int i; 614 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ 615 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 616 aObjCmd[i].xProc, aObjCmd[i].clientData, 0); 617 } 618 #endif 619 return TCL_OK; 620 } 621