/*

 ** 2006 June 13

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** Code for testing the virtual table interfaces.  This code

 ** is not included in the SQLite library.  It is used for automated

 ** testing of the SQLite library.

 **

 ** The emphasis of this file is a virtual table that provides

 ** access to TCL variables.

 **

 ** $Id: test_tclvar.c,v 1.17 2008/08/12 14:48:41 danielk1977 Exp $

 */

 #include "sqliteInt.h"

 #include "tcl.h"

 #include <stdlib.h>

 #include <string.h>

 #ifndef SQLITE_OMIT_VIRTUALTABLE

 typedef struct tclvar_vtab tclvar_vtab;

 typedef struct tclvar_cursor tclvar_cursor;

 /* 

 ** A tclvar virtual-table object 

 */

 struct tclvar_vtab {

   sqlite3_vtab base;

   Tcl_Interp *interp;

 };

 /* A tclvar cursor object */

 struct tclvar_cursor {

   sqlite3_vtab_cursor base;

   Tcl_Obj *pList1;     /* Result of [info vars ?pattern?] */

   Tcl_Obj *pList2;     /* Result of [array names [lindex $pList1 $i1]] */

   int i1;              /* Current item in pList1 */

   int i2;              /* Current item (if any) in pList2 */

 };

 /* Methods for the tclvar module */

 static int tclvarConnect(

   sqlite3 *db,

   void *pAux,

   int argc, const char *const*argv,

   sqlite3_vtab **ppVtab,

   char **pzErr

 ){

   tclvar_vtab *pVtab;

   static const char zSchema[] = 

      "CREATE TABLE whatever(name TEXT, arrayname TEXT, value TEXT)";

   pVtab = sqlite3MallocZero( sizeof(*pVtab) );

   if( pVtab==0 ) return SQLITE_NOMEM;

   *ppVtab = &pVtab->base;

   pVtab->interp = (Tcl_Interp *)pAux;

   sqlite3_declare_vtab(db, zSchema);

   return SQLITE_OK;

 }

 /* Note that for this virtual table, the xCreate and xConnect

 ** methods are identical. */

 static int tclvarDisconnect(sqlite3_vtab *pVtab){

   sqlite3_free(pVtab);

   return SQLITE_OK;

 }

 /* The xDisconnect and xDestroy methods are also the same */

 /*

 ** Open a new tclvar cursor.

 */

 static int tclvarOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor){

   tclvar_cursor *pCur;

   pCur = sqlite3MallocZero(sizeof(tclvar_cursor));

   *ppCursor = &pCur->base;

   return SQLITE_OK;

 }

 /*

 ** Close a tclvar cursor.

 */

 static int tclvarClose(sqlite3_vtab_cursor *cur){

   tclvar_cursor *pCur = (tclvar_cursor *)cur;

   if( pCur->pList1 ){

     Tcl_DecrRefCount(pCur->pList1);

   }

   if( pCur->pList2 ){

     Tcl_DecrRefCount(pCur->pList2);

   }

   sqlite3_free(pCur);

   return SQLITE_OK;

 }

 /*

 ** Returns 1 if data is ready, or 0 if not.

 */

 static int next2(Tcl_Interp *interp, tclvar_cursor *pCur, Tcl_Obj *pObj){

   Tcl_Obj *p;

   if( pObj ){

     if( !pCur->pList2 ){

       p = Tcl_NewStringObj("array names", -1);

       Tcl_IncrRefCount(p);

       Tcl_ListObjAppendElement(0, p, pObj);

       Tcl_EvalObjEx(interp, p, TCL_EVAL_GLOBAL);

       Tcl_DecrRefCount(p);

       pCur->pList2 = Tcl_GetObjResult(interp);

       Tcl_IncrRefCount(pCur->pList2);

       assert( pCur->i2==0 );

     }else{

       int n = 0;

       pCur->i2++;

       Tcl_ListObjLength(0, pCur->pList2, &n);

       if( pCur->i2>=n ){

         Tcl_DecrRefCount(pCur->pList2);

         pCur->pList2 = 0;

         pCur->i2 = 0;

         return 0;

       }

     }

   }

   return 1;

 }

 static int tclvarNext(sqlite3_vtab_cursor *cur){

   Tcl_Obj *pObj;

   int n = 0;

   int ok = 0;

   tclvar_cursor *pCur = (tclvar_cursor *)cur;

   Tcl_Interp *interp = ((tclvar_vtab *)(cur->pVtab))->interp;

   Tcl_ListObjLength(0, pCur->pList1, &n);

   while( !ok && pCur->i1<n ){

     Tcl_ListObjIndex(0, pCur->pList1, pCur->i1, &pObj);

     ok = next2(interp, pCur, pObj);

     if( !ok ){

       pCur->i1++;

     }

   }

   return 0;

 }

 static int tclvarFilter(

   sqlite3_vtab_cursor *pVtabCursor, 

   int idxNum, const char *idxStr,

   int argc, sqlite3_value **argv

 ){

   tclvar_cursor *pCur = (tclvar_cursor *)pVtabCursor;

   Tcl_Interp *interp = ((tclvar_vtab *)(pVtabCursor->pVtab))->interp;

   Tcl_Obj *p = Tcl_NewStringObj("info vars", -1);

   Tcl_IncrRefCount(p);

   assert( argc==0 || argc==1 );

   if( argc==1 ){

     Tcl_Obj *pArg = Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1);

     Tcl_ListObjAppendElement(0, p, pArg);

   }

   Tcl_EvalObjEx(interp, p, TCL_EVAL_GLOBAL);

   pCur->pList1 = Tcl_GetObjResult(interp);

   Tcl_IncrRefCount(pCur->pList1);

   assert( pCur->i1==0 && pCur->i2==0 && pCur->pList2==0 );

   Tcl_DecrRefCount(p);

   return tclvarNext(pVtabCursor);

 }

 static int tclvarColumn(sqlite3_vtab_cursor *cur, sqlite3_context *ctx, int i){

   Tcl_Obj *p1;

   Tcl_Obj *p2;

   const char *z1; 

   const char *z2 = "";

   tclvar_cursor *pCur = (tclvar_cursor*)cur;

   Tcl_Interp *interp = ((tclvar_vtab *)cur->pVtab)->interp;

   Tcl_ListObjIndex(interp, pCur->pList1, pCur->i1, &p1);

   Tcl_ListObjIndex(interp, pCur->pList2, pCur->i2, &p2);

   z1 = Tcl_GetString(p1);

   if( p2 ){

     z2 = Tcl_GetString(p2);

   }

   switch (i) {

     case 0: {

       sqlite3_result_text(ctx, z1, -1, SQLITE_TRANSIENT);

       break;

     }

     case 1: {

       sqlite3_result_text(ctx, z2, -1, SQLITE_TRANSIENT);

       break;

     }

     case 2: {

       Tcl_Obj *pVal = Tcl_GetVar2Ex(interp, z1, *z2?z2:0, TCL_GLOBAL_ONLY);

       sqlite3_result_text(ctx, Tcl_GetString(pVal), -1, SQLITE_TRANSIENT);

       break;

     }

   }

   return SQLITE_OK;

 }

 static int tclvarRowid(sqlite3_vtab_cursor *cur, sqlite_int64 *pRowid){

   *pRowid = 0;

   return SQLITE_OK;

 }

 static int tclvarEof(sqlite3_vtab_cursor *cur){

   tclvar_cursor *pCur = (tclvar_cursor*)cur;

   return (pCur->pList2?0:1);

 }

 static int tclvarBestIndex(sqlite3_vtab *tab, sqlite3_index_info *pIdxInfo){

   int ii;

   for(ii=0; ii<pIdxInfo->nConstraint; ii++){

     struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];

     if( pCons->iColumn==0 && pCons->usable

            && pCons->op==SQLITE_INDEX_CONSTRAINT_EQ ){

       struct sqlite3_index_constraint_usage *pUsage;

       pUsage = &pIdxInfo->aConstraintUsage[ii];

       pUsage->omit = 0;

       pUsage->argvIndex = 1;

       return SQLITE_OK;

     }

   }

   for(ii=0; ii<pIdxInfo->nConstraint; ii++){

     struct sqlite3_index_constraint const *pCons = &pIdxInfo->aConstraint[ii];

     if( pCons->iColumn==0 && pCons->usable

            && pCons->op==SQLITE_INDEX_CONSTRAINT_MATCH ){

       struct sqlite3_index_constraint_usage *pUsage;

       pUsage = &pIdxInfo->aConstraintUsage[ii];

       pUsage->omit = 1;

       pUsage->argvIndex = 1;

       return SQLITE_OK;

     }

   }

   return SQLITE_OK;

 }

 /*

 ** A virtual table module that provides read-only access to a

 ** Tcl global variable namespace.

 */

 static sqlite3_module tclvarModule = {

   0,                         /* iVersion */

   tclvarConnect,

   tclvarConnect,

   tclvarBestIndex,

   tclvarDisconnect, 

   tclvarDisconnect,

   tclvarOpen,                  /* xOpen - open a cursor */

   tclvarClose,                 /* xClose - close a cursor */

   tclvarFilter,                /* xFilter - configure scan constraints */

   tclvarNext,                  /* xNext - advance a cursor */

   tclvarEof,                   /* xEof - check for end of scan */

   tclvarColumn,                /* xColumn - read data */

   tclvarRowid,                 /* xRowid - read data */

   0,                           /* xUpdate */

   0,                           /* xBegin */

   0,                           /* xSync */

   0,                           /* xCommit */

   0,                           /* xRollback */

   0,                           /* xFindMethod */

   0,                           /* xRename */

 };

 /*

 ** Decode a pointer to an sqlite3 object.

 */

 extern int getDbPointer(Tcl_Interp *interp, const char *zA, sqlite3 **ppDb);

 /*

 ** Register the echo virtual table module.

 */

 static int register_tclvar_module(

   ClientData clientData, /* Pointer to sqlite3_enable_XXX function */

   Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */

   int objc,              /* Number of arguments */

   Tcl_Obj *CONST objv[]  /* Command arguments */

 ){

   sqlite3 *db;

   if( objc!=2 ){

     Tcl_WrongNumArgs(interp, 1, objv, "DB");

     return TCL_ERROR;

   }

   if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;

 #ifndef SQLITE_OMIT_VIRTUALTABLE

   sqlite3_create_module(db, "tclvar", &tclvarModule, (void *)interp);

 #endif

   return TCL_OK;

 }

 #endif

 /*

 ** Register commands with the TCL interpreter.

 */

 int Sqlitetesttclvar_Init(Tcl_Interp *interp){

 #ifndef SQLITE_OMIT_VIRTUALTABLE

   static struct {

      char *zName;

      Tcl_ObjCmdProc *xProc;

      void *clientData;

   } aObjCmd[] = {

      { "register_tclvar_module",   register_tclvar_module, 0 },

   };

   int i;

   for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){

     Tcl_CreateObjCommand(interp, aObjCmd[i].zName, 

         aObjCmd[i].xProc, aObjCmd[i].clientData, 0);

   }

 #endif

   return TCL_OK;

 }