/*

** 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;

}