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 */
tclDequote(char * z)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 */
tclConnect(sqlite3 * db,void * pAux,int argc,const char * const * argv,sqlite3_vtab ** ppVtab,char ** pzErr)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 */
tclDisconnect(sqlite3_vtab * pVtab)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 */
tclOpen(sqlite3_vtab * pVTab,sqlite3_vtab_cursor ** ppCursor)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 */
tclClose(sqlite3_vtab_cursor * cur)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
tclNext(sqlite3_vtab_cursor * pVtabCursor)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
tclFilter(sqlite3_vtab_cursor * pVtabCursor,int idxNum,const char * idxStr,int argc,sqlite3_value ** argv)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 sqlite3_value *pMem;
303 pVal = Tcl_NewObj();
304 for(rc=sqlite3_vtab_in_first(argv[ii], &pMem);
305 rc==SQLITE_OK && pMem;
306 rc=sqlite3_vtab_in_next(argv[ii], &pMem)
307 ){
308 Tcl_Obj *pVal2 = 0;
309 zVal = (const char*)sqlite3_value_text(pMem);
310 if( zVal ){
311 pVal2 = Tcl_NewStringObj(zVal, -1);
312 }else{
313 pVal2 = Tcl_NewObj();
314 }
315 Tcl_ListObjAppendElement(interp, pVal, pVal2);
316 }
317 }else{
318 pVal = Tcl_NewStringObj(zVal, -1);
319 }
320 Tcl_ListObjAppendElement(interp, pArg, pVal);
321 }
322 Tcl_ListObjAppendElement(interp, pScript, pArg);
323 Tcl_DecrRefCount(pArg);
324
325 rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL);
326 if( rc!=TCL_OK ){
327 const char *zErr = Tcl_GetStringResult(interp);
328 rc = SQLITE_ERROR;
329 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
330 }else{
331 /* Analyze the scripts return value. The return value should be a tcl
332 ** list object with an even number of elements. The first element of each
333 ** pair must be one of:
334 **
335 ** "sql" (SQL statement to return data)
336 */
337 Tcl_Obj *pRes = Tcl_GetObjResult(interp);
338 Tcl_Obj **apElem = 0;
339 int nElem;
340 rc = Tcl_ListObjGetElements(interp, pRes, &nElem, &apElem);
341 if( rc!=TCL_OK ){
342 const char *zErr = Tcl_GetStringResult(interp);
343 rc = SQLITE_ERROR;
344 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
345 }else{
346 for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){
347 const char *zCmd = Tcl_GetString(apElem[ii]);
348 Tcl_Obj *p = apElem[ii+1];
349 if( sqlite3_stricmp("sql", zCmd)==0 ){
350 const char *zSql = Tcl_GetString(p);
351 rc = sqlite3_prepare_v2(pTab->db, zSql, -1, &pCsr->pStmt, 0);
352 if( rc!=SQLITE_OK ){
353 const char *zErr = sqlite3_errmsg(pTab->db);
354 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zErr);
355 }
356 }else{
357 rc = SQLITE_ERROR;
358 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zCmd);
359 }
360 }
361 }
362 }
363
364 if( rc==SQLITE_OK ){
365 rc = tclNext(pVtabCursor);
366 }
367 return rc;
368 }
369
tclColumn(sqlite3_vtab_cursor * pVtabCursor,sqlite3_context * ctx,int i)370 static int tclColumn(
371 sqlite3_vtab_cursor *pVtabCursor,
372 sqlite3_context *ctx,
373 int i
374 ){
375 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
376 sqlite3_result_value(ctx, sqlite3_column_value(pCsr->pStmt, i+1));
377 return SQLITE_OK;
378 }
379
tclRowid(sqlite3_vtab_cursor * pVtabCursor,sqlite_int64 * pRowid)380 static int tclRowid(sqlite3_vtab_cursor *pVtabCursor, sqlite_int64 *pRowid){
381 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
382 *pRowid = sqlite3_column_int64(pCsr->pStmt, 0);
383 return SQLITE_OK;
384 }
385
tclEof(sqlite3_vtab_cursor * pVtabCursor)386 static int tclEof(sqlite3_vtab_cursor *pVtabCursor){
387 tcl_cursor *pCsr = (tcl_cursor*)pVtabCursor;
388 return (pCsr->pStmt==0);
389 }
390
testBestIndexObjConstraints(Tcl_Interp * interp,sqlite3_index_info * pIdxInfo)391 static void testBestIndexObjConstraints(
392 Tcl_Interp *interp,
393 sqlite3_index_info *pIdxInfo
394 ){
395 int ii;
396 Tcl_Obj *pRes = Tcl_NewObj();
397 Tcl_IncrRefCount(pRes);
398 for(ii=0; ii<pIdxInfo->nConstraint; ii++){
399 struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];
400 Tcl_Obj *pElem = Tcl_NewObj();
401 const char *zOp = "?";
402
403 Tcl_IncrRefCount(pElem);
404
405 switch( pCons->op ){
406 case SQLITE_INDEX_CONSTRAINT_EQ:
407 zOp = "eq"; break;
408 case SQLITE_INDEX_CONSTRAINT_GT:
409 zOp = "gt"; break;
410 case SQLITE_INDEX_CONSTRAINT_LE:
411 zOp = "le"; break;
412 case SQLITE_INDEX_CONSTRAINT_LT:
413 zOp = "lt"; break;
414 case SQLITE_INDEX_CONSTRAINT_GE:
415 zOp = "ge"; break;
416 case SQLITE_INDEX_CONSTRAINT_MATCH:
417 zOp = "match"; break;
418 case SQLITE_INDEX_CONSTRAINT_LIKE:
419 zOp = "like"; break;
420 case SQLITE_INDEX_CONSTRAINT_GLOB:
421 zOp = "glob"; break;
422 case SQLITE_INDEX_CONSTRAINT_REGEXP:
423 zOp = "regexp"; break;
424 case SQLITE_INDEX_CONSTRAINT_NE:
425 zOp = "ne"; break;
426 case SQLITE_INDEX_CONSTRAINT_ISNOT:
427 zOp = "isnot"; break;
428 case SQLITE_INDEX_CONSTRAINT_ISNOTNULL:
429 zOp = "isnotnull"; break;
430 case SQLITE_INDEX_CONSTRAINT_ISNULL:
431 zOp = "isnull"; break;
432 case SQLITE_INDEX_CONSTRAINT_IS:
433 zOp = "is"; break;
434 case SQLITE_INDEX_CONSTRAINT_LIMIT:
435 zOp = "limit"; break;
436 case SQLITE_INDEX_CONSTRAINT_OFFSET:
437 zOp = "offset"; break;
438 }
439
440 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("op", -1));
441 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj(zOp, -1));
442 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("column", -1));
443 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->iColumn));
444 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("usable", -1));
445 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pCons->usable));
446
447 Tcl_ListObjAppendElement(0, pRes, pElem);
448 Tcl_DecrRefCount(pElem);
449 }
450
451 Tcl_SetObjResult(interp, pRes);
452 Tcl_DecrRefCount(pRes);
453 }
454
testBestIndexObjOrderby(Tcl_Interp * interp,sqlite3_index_info * pIdxInfo)455 static void testBestIndexObjOrderby(
456 Tcl_Interp *interp,
457 sqlite3_index_info *pIdxInfo
458 ){
459 int ii;
460 Tcl_Obj *pRes = Tcl_NewObj();
461 Tcl_IncrRefCount(pRes);
462 for(ii=0; ii<pIdxInfo->nOrderBy; ii++){
463 struct sqlite3_index_orderby const *pOrder = &pIdxInfo->aOrderBy[ii];
464 Tcl_Obj *pElem = Tcl_NewObj();
465 Tcl_IncrRefCount(pElem);
466
467 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("column", -1));
468 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->iColumn));
469 Tcl_ListObjAppendElement(0, pElem, Tcl_NewStringObj("desc", -1));
470 Tcl_ListObjAppendElement(0, pElem, Tcl_NewIntObj(pOrder->desc));
471
472 Tcl_ListObjAppendElement(0, pRes, pElem);
473 Tcl_DecrRefCount(pElem);
474 }
475
476 Tcl_SetObjResult(interp, pRes);
477 Tcl_DecrRefCount(pRes);
478 }
479
480 /*
481 ** Implementation of the handle passed to each xBestIndex callback. This
482 ** object features the following sub-commands:
483 **
484 ** $hdl constraints
485 ** $hdl orderby
486 ** $hdl mask
487 **
488 ** $hdl distinct
489 ** Return the result (an integer) of calling sqlite3_vtab_distinct()
490 ** on the index-info structure.
491 **
492 ** $hdl in IDX BOOLEAN
493 ** Wrapper around sqlite3_vtab_in(). Returns an integer.
494 **
495 ** $hdl rhs_value IDX ?DEFAULT?
496 ** Wrapper around sqlite3_vtab_rhs_value().
497 */
testBestIndexObj(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])498 static int SQLITE_TCLAPI testBestIndexObj(
499 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
500 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
501 int objc, /* Number of arguments */
502 Tcl_Obj *CONST objv[] /* Command arguments */
503 ){
504 const char *azSub[] = {
505 "constraints", /* 0 */
506 "orderby", /* 1 */
507 "mask", /* 2 */
508 "distinct", /* 3 */
509 "in", /* 4 */
510 "rhs_value", /* 5 */
511 0
512 };
513 int ii;
514 sqlite3_index_info *pIdxInfo = (sqlite3_index_info*)clientData;
515
516 if( objc<2 ){
517 Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND");
518 return TCL_ERROR;
519 }
520 if( Tcl_GetIndexFromObj(interp, objv[1], azSub, "sub-command", 0, &ii) ){
521 return TCL_ERROR;
522 }
523
524 if( ii<4 && objc!=2 ){
525 Tcl_WrongNumArgs(interp, 2, objv, "");
526 return TCL_ERROR;
527 }
528 if( ii==4 && objc!=4 ){
529 Tcl_WrongNumArgs(interp, 2, objv, "INDEX BOOLEAN");
530 return TCL_ERROR;
531 }
532 if( ii==5 && objc!=3 && objc!=4 ){
533 Tcl_WrongNumArgs(interp, 2, objv, "INDEX ?DEFAULT?");
534 return TCL_ERROR;
535 }
536
537 switch( ii ){
538 case 0: assert( sqlite3_stricmp(azSub[ii], "constraints")==0 );
539 testBestIndexObjConstraints(interp, pIdxInfo);
540 break;
541
542 case 1: assert( sqlite3_stricmp(azSub[ii], "orderby")==0 );
543 testBestIndexObjOrderby(interp, pIdxInfo);
544 break;
545
546 case 2: assert( sqlite3_stricmp(azSub[ii], "mask")==0 );
547 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(pIdxInfo->colUsed));
548 break;
549
550 case 3: assert( sqlite3_stricmp(azSub[ii], "distinct")==0 ); {
551 int bDistinct = sqlite3_vtab_distinct(pIdxInfo);
552 Tcl_SetObjResult(interp, Tcl_NewIntObj(bDistinct));
553 break;
554 }
555
556 case 4: assert( sqlite3_stricmp(azSub[ii], "in")==0 ); {
557 int iCons;
558 int bHandle;
559 if( Tcl_GetIntFromObj(interp, objv[2], &iCons)
560 || Tcl_GetBooleanFromObj(interp, objv[3], &bHandle)
561 ){
562 return TCL_ERROR;
563 }
564 Tcl_SetObjResult(interp,
565 Tcl_NewIntObj(sqlite3_vtab_in(pIdxInfo, iCons, bHandle))
566 );
567 break;
568 }
569
570 case 5: assert( sqlite3_stricmp(azSub[ii], "rhs_value")==0 ); {
571 int iCons = 0;
572 int rc;
573 sqlite3_value *pVal = 0;
574 const char *zVal = "";
575 if( Tcl_GetIntFromObj(interp, objv[2], &iCons) ){
576 return TCL_ERROR;
577 }
578 rc = sqlite3_vtab_rhs_value(pIdxInfo, iCons, &pVal);
579 if( rc!=SQLITE_OK && rc!=SQLITE_NOTFOUND ){
580 Tcl_SetResult(interp, (char *)sqlite3ErrName(rc), TCL_VOLATILE);
581 return TCL_ERROR;
582 }
583 if( pVal ){
584 zVal = (const char*)sqlite3_value_text(pVal);
585 }else if( objc==4 ){
586 zVal = Tcl_GetString(objv[3]);
587 }
588 Tcl_SetObjResult(interp, Tcl_NewStringObj(zVal, -1));
589 break;
590 }
591 }
592
593 return TCL_OK;
594 }
595
tclBestIndex(sqlite3_vtab * tab,sqlite3_index_info * pIdxInfo)596 static int tclBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){
597 tcl_vtab *pTab = (tcl_vtab*)tab;
598 Tcl_Interp *interp = pTab->interp;
599 int rc = SQLITE_OK;
600
601 static int iNext = 43;
602 char zHdl[24];
603 Tcl_Obj *pScript;
604
605 pScript = Tcl_DuplicateObj(pTab->pCmd);
606 Tcl_IncrRefCount(pScript);
607 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj("xBestIndex", -1));
608
609 sqlite3_snprintf(sizeof(zHdl), zHdl, "bestindex%d", iNext++);
610 Tcl_CreateObjCommand(interp, zHdl, testBestIndexObj, pIdxInfo, 0);
611 Tcl_ListObjAppendElement(interp, pScript, Tcl_NewStringObj(zHdl, -1));
612 rc = Tcl_EvalObjEx(interp, pScript, TCL_EVAL_GLOBAL);
613 Tcl_DeleteCommand(interp, zHdl);
614 Tcl_DecrRefCount(pScript);
615
616 if( rc!=TCL_OK ){
617 const char *zErr = Tcl_GetStringResult(interp);
618 rc = SQLITE_ERROR;
619 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
620 }else{
621 /* Analyze the scripts return value. The return value should be a tcl
622 ** list object with an even number of elements. The first element of each
623 ** pair must be one of:
624 **
625 ** "orderby" (value of orderByConsumed flag)
626 ** "cost" (value of estimatedCost field)
627 ** "rows" (value of estimatedRows field)
628 ** "use" (index of used constraint in aConstraint[])
629 ** "idxnum" (value of idxNum field)
630 ** "idxstr" (value of idxStr field)
631 ** "omit" (index of omitted constraint in aConstraint[])
632 */
633 Tcl_Obj *pRes = Tcl_GetObjResult(interp);
634 Tcl_Obj **apElem = 0;
635 int nElem;
636 rc = Tcl_ListObjGetElements(interp, pRes, &nElem, &apElem);
637 if( rc!=TCL_OK ){
638 const char *zErr = Tcl_GetStringResult(interp);
639 rc = SQLITE_ERROR;
640 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
641 }else{
642 int ii;
643 int iArgv = 1;
644 for(ii=0; rc==SQLITE_OK && ii<nElem; ii+=2){
645 const char *zCmd = Tcl_GetString(apElem[ii]);
646 Tcl_Obj *p = apElem[ii+1];
647 if( sqlite3_stricmp("cost", zCmd)==0 ){
648 rc = Tcl_GetDoubleFromObj(interp, p, &pIdxInfo->estimatedCost);
649 }else
650 if( sqlite3_stricmp("orderby", zCmd)==0 ){
651 rc = Tcl_GetIntFromObj(interp, p, &pIdxInfo->orderByConsumed);
652 }else
653 if( sqlite3_stricmp("idxnum", zCmd)==0 ){
654 rc = Tcl_GetIntFromObj(interp, p, &pIdxInfo->idxNum);
655 }else
656 if( sqlite3_stricmp("idxstr", zCmd)==0 ){
657 sqlite3_free(pIdxInfo->idxStr);
658 pIdxInfo->idxStr = sqlite3_mprintf("%s", Tcl_GetString(p));
659 pIdxInfo->needToFreeIdxStr = 1;
660 }else
661 if( sqlite3_stricmp("rows", zCmd)==0 ){
662 Tcl_WideInt x = 0;
663 rc = Tcl_GetWideIntFromObj(interp, p, &x);
664 pIdxInfo->estimatedRows = (tRowcnt)x;
665 }else
666 if( sqlite3_stricmp("use", zCmd)==0
667 || sqlite3_stricmp("omit", zCmd)==0
668 ){
669 int iCons;
670 rc = Tcl_GetIntFromObj(interp, p, &iCons);
671 if( rc==SQLITE_OK ){
672 if( iCons<0 || iCons>=pIdxInfo->nConstraint ){
673 rc = SQLITE_ERROR;
674 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %d", iCons);
675 }else{
676 int bOmit = (zCmd[0]=='o' || zCmd[0]=='O');
677 pIdxInfo->aConstraintUsage[iCons].argvIndex = iArgv++;
678 pIdxInfo->aConstraintUsage[iCons].omit = bOmit;
679 }
680 }
681 }else{
682 rc = SQLITE_ERROR;
683 pTab->base.zErrMsg = sqlite3_mprintf("unexpected: %s", zCmd);
684 }
685 if( rc!=SQLITE_OK && pTab->base.zErrMsg==0 ){
686 const char *zErr = Tcl_GetStringResult(interp);
687 pTab->base.zErrMsg = sqlite3_mprintf("%s", zErr);
688 }
689 }
690 }
691 }
692
693 return rc;
694 }
695
696 /*
697 ** A virtual table module that provides read-only access to a
698 ** Tcl global variable namespace.
699 */
700 static sqlite3_module tclModule = {
701 0, /* iVersion */
702 tclConnect,
703 tclConnect,
704 tclBestIndex,
705 tclDisconnect,
706 tclDisconnect,
707 tclOpen, /* xOpen - open a cursor */
708 tclClose, /* xClose - close a cursor */
709 tclFilter, /* xFilter - configure scan constraints */
710 tclNext, /* xNext - advance a cursor */
711 tclEof, /* xEof - check for end of scan */
712 tclColumn, /* xColumn - read data */
713 tclRowid, /* xRowid - read data */
714 0, /* xUpdate */
715 0, /* xBegin */
716 0, /* xSync */
717 0, /* xCommit */
718 0, /* xRollback */
719 0, /* xFindMethod */
720 0, /* xRename */
721 };
722
723 /*
724 ** Decode a pointer to an sqlite3 object.
725 */
726 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);
727
728 /*
729 ** Register the echo virtual table module.
730 */
register_tcl_module(ClientData clientData,Tcl_Interp * interp,int objc,Tcl_Obj * CONST objv[])731 static int SQLITE_TCLAPI register_tcl_module(
732 ClientData clientData, /* Pointer to sqlite3_enable_XXX function */
733 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
734 int objc, /* Number of arguments */
735 Tcl_Obj *CONST objv[] /* Command arguments */
736 ){
737 sqlite3 *db;
738 if( objc!=2 ){
739 Tcl_WrongNumArgs(interp, 1, objv, "DB");
740 return TCL_ERROR;
741 }
742 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
743 #ifndef SQLITE_OMIT_VIRTUALTABLE
744 sqlite3_create_module(db, "tcl", &tclModule, (void *)interp);
745 #endif
746 return TCL_OK;
747 }
748
749 #endif
750
751
752 /*
753 ** Register commands with the TCL interpreter.
754 */
Sqlitetesttcl_Init(Tcl_Interp * interp)755 int Sqlitetesttcl_Init(Tcl_Interp *interp){
756 #ifndef SQLITE_OMIT_VIRTUALTABLE
757 static struct {
758 char *zName;
759 Tcl_ObjCmdProc *xProc;
760 void *clientData;
761 } aObjCmd[] = {
762 { "register_tcl_module", register_tcl_module, 0 },
763 };
764 int i;
765 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
766 Tcl_CreateObjCommand(interp, aObjCmd[i].zName,
767 aObjCmd[i].xProc, aObjCmd[i].clientData, 0);
768 }
769 #endif
770 return TCL_OK;
771 }
772