/*

** 2006 June 10

**

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

**

** $Id: test_schema.c,v 1.15 2008/07/07 14:50:14 drh Exp $

*/

/* The code in this file defines a sqlite3 virtual-table module that

** provides a read-only view of the current database schema. There is one

** row in the schema table for each column in the database schema.

*/

#define SCHEMA \

"CREATE TABLE x("                                                            \

  "database,"          /* Name of database (i.e. main, temp etc.) */         \

  "tablename,"         /* Name of table */                                   \

  "cid,"               /* Column number (from left-to-right, 0 upward) */    \

  "name,"              /* Column name */                                     \

  "type,"              /* Specified type (i.e. VARCHAR(32)) */               \

  "not_null,"          /* Boolean. True if NOT NULL was specified */         \

  "dflt_value,"        /* Default value for this column */                   \

  "pk"                 /* True if this column is part of the primary key */  \

")"

/* If SQLITE_TEST is defined this code is preprocessed for use as part

** of the sqlite test binary "testfixture". Otherwise it is preprocessed

** to be compiled into an sqlite dynamic extension.

*/

#ifdef SQLITE_TEST

  #include "sqliteInt.h"

  #include "tcl.h"

#else

  #include "sqlite3ext.h"

  SQLITE_EXTENSION_INIT1

#endif

#include <stdlib.h>

#include <string.h>

#include <assert.h>

typedef struct schema_vtab schema_vtab;

typedef struct schema_cursor schema_cursor;

/* A schema table object */

struct schema_vtab {

  sqlite3_vtab base;

  sqlite3 *db;

};

/* A schema table cursor object */

struct schema_cursor {

  sqlite3_vtab_cursor base;

  sqlite3_stmt *pDbList;

  sqlite3_stmt *pTableList;

  sqlite3_stmt *pColumnList;

  int rowid;

};

/*

** None of this works unless we have virtual tables.

*/

#ifndef SQLITE_OMIT_VIRTUALTABLE

/*

** Table destructor for the schema module.

*/

static int schemaDestroy(sqlite3_vtab *pVtab){

  sqlite3_free(pVtab);

  return 0;

}

/*

** Table constructor for the schema module.

*/

static int schemaCreate(

  sqlite3 *db,

  void *pAux,

  int argc, const char *const*argv,

  sqlite3_vtab **ppVtab,

  char **pzErr

){

  int rc = SQLITE_NOMEM;

  schema_vtab *pVtab = sqlite3_malloc(sizeof(schema_vtab));

  if( pVtab ){

    memset(pVtab, 0, sizeof(schema_vtab));

    pVtab->db = db;

#ifndef SQLITE_OMIT_VIRTUALTABLE

    rc = sqlite3_declare_vtab(db, SCHEMA);

#endif

  }

  *ppVtab = (sqlite3_vtab *)pVtab;

  return rc;

}

/*

** Open a new cursor on the schema table.

*/

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

  int rc = SQLITE_NOMEM;

  schema_cursor *pCur;

  pCur = sqlite3_malloc(sizeof(schema_cursor));

  if( pCur ){

    memset(pCur, 0, sizeof(schema_cursor));

    *ppCursor = (sqlite3_vtab_cursor *)pCur;

    rc = SQLITE_OK;

  }

  return rc;

}

/*

** Close a schema table cursor.

*/

static int schemaClose(sqlite3_vtab_cursor *cur){

  schema_cursor *pCur = (schema_cursor *)cur;

  sqlite3_finalize(pCur->pDbList);

  sqlite3_finalize(pCur->pTableList);

  sqlite3_finalize(pCur->pColumnList);

  sqlite3_free(pCur);

  return SQLITE_OK;

}

/*

** Retrieve a column of data.

*/

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

  schema_cursor *pCur = (schema_cursor *)cur;

  switch( i ){

    case 0:

      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pDbList, 1));

      break;

    case 1:

      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pTableList, 0));

      break;

    default:

      sqlite3_result_value(ctx, sqlite3_column_value(pCur->pColumnList, i-2));

      break;

  }

  return SQLITE_OK;

}

/*

** Retrieve the current rowid.

*/

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

  schema_cursor *pCur = (schema_cursor *)cur;

  *pRowid = pCur->rowid;

  return SQLITE_OK;

}

static int finalize(sqlite3_stmt **ppStmt){

  int rc = sqlite3_finalize(*ppStmt);

  *ppStmt = 0;

  return rc;

}

static int schemaEof(sqlite3_vtab_cursor *cur){

  schema_cursor *pCur = (schema_cursor *)cur;

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

}

/*

** Advance the cursor to the next row.

*/

static int schemaNext(sqlite3_vtab_cursor *cur){

  int rc = SQLITE_OK;

  schema_cursor *pCur = (schema_cursor *)cur;

  schema_vtab *pVtab = (schema_vtab *)(cur->pVtab);

  char *zSql = 0;

  while( !pCur->pColumnList || SQLITE_ROW!=sqlite3_step(pCur->pColumnList) ){

    if( SQLITE_OK!=(rc = finalize(&pCur->pColumnList)) ) goto next_exit;

    while( !pCur->pTableList || SQLITE_ROW!=sqlite3_step(pCur->pTableList) ){

      if( SQLITE_OK!=(rc = finalize(&pCur->pTableList)) ) goto next_exit;

      assert(pCur->pDbList);

      while( SQLITE_ROW!=sqlite3_step(pCur->pDbList) ){

        rc = finalize(&pCur->pDbList);

        goto next_exit;

      }

      /* Set zSql to the SQL to pull the list of tables from the 

      ** sqlite_master (or sqlite_temp_master) table of the database

      ** identfied by the row pointed to by the SQL statement pCur->pDbList

      ** (iterating through a "PRAGMA database_list;" statement).

      */

      if( sqlite3_column_int(pCur->pDbList, 0)==1 ){

        zSql = sqlite3_mprintf(

            "SELECT name FROM sqlite_temp_master WHERE type='table'"

        );

      }else{

        sqlite3_stmt *pDbList = pCur->pDbList;

        zSql = sqlite3_mprintf(

            "SELECT name FROM %Q.sqlite_master WHERE type='table'",

             sqlite3_column_text(pDbList, 1)

        );

      }

      if( !zSql ){

        rc = SQLITE_NOMEM;

        goto next_exit;

      }

      rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pTableList, 0);

      sqlite3_free(zSql);

      if( rc!=SQLITE_OK ) goto next_exit;

    }

    /* Set zSql to the SQL to the table_info pragma for the table currently

    ** identified by the rows pointed to by statements pCur->pDbList and

    ** pCur->pTableList.

    */

    zSql = sqlite3_mprintf("PRAGMA %Q.table_info(%Q)", 

        sqlite3_column_text(pCur->pDbList, 1),

        sqlite3_column_text(pCur->pTableList, 0)

    );

    if( !zSql ){

      rc = SQLITE_NOMEM;

      goto next_exit;

    }

    rc = sqlite3_prepare(pVtab->db, zSql, -1, &pCur->pColumnList, 0);

    sqlite3_free(zSql);

    if( rc!=SQLITE_OK ) goto next_exit;

  }

  pCur->rowid++;

next_exit:

  /* TODO: Handle rc */

  return rc;

}

/*

** Reset a schema table cursor.

*/

static int schemaFilter(

  sqlite3_vtab_cursor *pVtabCursor, 

  int idxNum, const char *idxStr,

  int argc, sqlite3_value **argv

){

  int rc;

  schema_vtab *pVtab = (schema_vtab *)(pVtabCursor->pVtab);

  schema_cursor *pCur = (schema_cursor *)pVtabCursor;

  pCur->rowid = 0;

  finalize(&pCur->pTableList);

  finalize(&pCur->pColumnList);

  finalize(&pCur->pDbList);

  rc = sqlite3_prepare(pVtab->db,"PRAGMA database_list", -1, &pCur->pDbList, 0);

  return (rc==SQLITE_OK ? schemaNext(pVtabCursor) : rc);

}

/*

** Analyse the WHERE condition.

*/

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

  return SQLITE_OK;

}

/*

** A virtual table module that merely echos method calls into TCL

** variables.

*/

static sqlite3_module schemaModule = {

  0,                           /* iVersion */

  schemaCreate,

  schemaCreate,

  schemaBestIndex,

  schemaDestroy,

  schemaDestroy,

  schemaOpen,                  /* xOpen - open a cursor */

  schemaClose,                 /* xClose - close a cursor */

  schemaFilter,                /* xFilter - configure scan constraints */

  schemaNext,                  /* xNext - advance a cursor */

  schemaEof,                   /* xEof */

  schemaColumn,                /* xColumn - read data */

  schemaRowid,                 /* xRowid - read data */

  0,                           /* xUpdate */

  0,                           /* xBegin */

  0,                           /* xSync */

  0,                           /* xCommit */

  0,                           /* xRollback */

  0,                           /* xFindMethod */

  0,                           /* xRename */

};

#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */

#ifdef SQLITE_TEST

/*

** Decode a pointer to an sqlite3 object.

*/

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

/*

** Register the schema virtual table module.

*/

static int register_schema_module(

  ClientData clientData, /* Not used */

  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, "schema", &schemaModule, 0);

#endif

  return TCL_OK;

}

/*

** Register commands with the TCL interpreter.

*/

int Sqlitetestschema_Init(Tcl_Interp *interp){

  static struct {

     char *zName;

     Tcl_ObjCmdProc *xProc;

     void *clientData;

  } aObjCmd[] = {

     { "register_schema_module", register_schema_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);

  }

  return TCL_OK;

}

#else

/*

** Extension load function.

*/

int sqlite3_extension_init(

  sqlite3 *db, 

  char **pzErrMsg, 

  const sqlite3_api_routines *pApi

){

  SQLITE_EXTENSION_INIT2(pApi);

#ifndef SQLITE_OMIT_VIRTUALTABLE

  sqlite3_create_module(db, "schema", &schemaModule, 0);

#endif

  return 0;

}

#endif