wasCSharpSQLite – Rev
?pathlinks?
using System;
using System.Diagnostics;
using System.Text;
using i64 = System.Int64;
using u8 = System.Byte;
namespace Community.CsharpSqlite
{
#if TCLSH
using tcl.lang;
using sqlite_int64 = System.Int64;
using sqlite3_stmt = Sqlite3.Vdbe;
using sqlite3_value = Sqlite3.Mem;
using Tcl_Interp = tcl.lang.Interp;
using Tcl_Obj = tcl.lang.TclObject;
using ClientData = System.Object;
public partial class Sqlite3
{
/*
** 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.
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
**
*************************************************************************
*/
/* 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 */ \
//")"
const string SCHEMA = "CREATE TABLE x(" +
"database," +
"tablename," +
"cid," +
"name," +
"type," +
"not_null," +
"dflt_value," +
"pk" +
")";
/* 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.
*/
//#if SQLITE_TEST
// #include "sqliteInt.h"
// #include "tcl.h"
//#else
// #include "sqlite3ext.h"
// SQLITE_EXTENSION_INIT1
//#endif
//#include <stdlib.h>
//#include <string.h>
//#include <Debug.Assert.h>
//typedef struct schema_vtab schema_vtab;
//typedef struct schema_cursor schema_cursor;
/* A schema table object */
class schema_vtab : sqlite3_vtab
{
// sqlite3_vtab base;
public sqlite3 db;
};
/* A schema table cursor object */
class schema_cursor : sqlite3_vtab_cursor
{
//sqlite3_vtab_cursor base;
public sqlite3_stmt pDbList;
public sqlite3_stmt pTableList;
public sqlite3_stmt pColumnList;
public int rowid;
};
/*
** None of this works unless we have virtual tables.
*/
#if !SQLITE_OMIT_VIRTUALTABLE
/*
** Table destructor for the schema module.
*/
static int schemaDestroy( ref object pVtab )
{
pVtab = null;//sqlite3_free(pVtab);
return 0;
}
/*
** Table constructor for the schema module.
*/
static int schemaCreate(
sqlite3 db,
object pAux,
int argc,
string[] argv,
out sqlite3_vtab ppVtab,
out string pzErr
)
{
int rc = SQLITE_NOMEM;
schema_vtab pVtab = new schema_vtab();//sqlite3_malloc(sizeof(schema_vtab));
if ( pVtab != null )
{
//memset(pVtab, 0, sizeof(schema_vtab));
pVtab.db = db;
#if !SQLITE_OMIT_VIRTUALTABLE
rc = sqlite3_declare_vtab( db, SCHEMA );
#endif
}
ppVtab = (sqlite3_vtab)pVtab;
pzErr = "";
return rc;
}
/*
** Open a new cursor on the schema table.
*/
static int schemaOpen( sqlite3_vtab pVTab, out sqlite3_vtab_cursor ppCursor )
{
int rc = SQLITE_NOMEM;
schema_cursor pCur;
pCur = new schema_cursor();//pCur = sqlite3_malloc(sizeof(schema_cursor));
//if ( pCur != null )
//{
//memset(pCur, 0, sizeof(schema_cursor));
ppCursor = (sqlite3_vtab_cursor)pCur;
rc = SQLITE_OK;
//}
return rc;
}
/*
** Close a schema table cursor.
*/
static int schemaClose( ref 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 );
cur = null;//
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, out sqlite_int64 pRowid )
{
schema_cursor pCur = (schema_cursor)cur;
pRowid = pCur.rowid;
return SQLITE_OK;
}
static int finalize( ref sqlite3_stmt ppStmt )
{
int rc = sqlite3_finalize( ppStmt );
ppStmt = null;
return rc;
}
static int schemaEof( sqlite3_vtab_cursor cur )
{
schema_cursor pCur = (schema_cursor)cur;
return ( pCur.pDbList != null ? 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 );
string zSql = null;
while ( null == pCur.pColumnList || SQLITE_ROW != sqlite3_step( pCur.pColumnList ) )
{
if ( SQLITE_OK != ( rc = finalize( ref pCur.pColumnList ) ) )
goto next_exit;
while ( null == pCur.pTableList || SQLITE_ROW != sqlite3_step( pCur.pTableList ) )
{
if ( SQLITE_OK != ( rc = finalize( ref pCur.pTableList ) ) )
goto next_exit;
Debug.Assert( pCur.pDbList !=null);
while ( SQLITE_ROW != sqlite3_step( pCur.pDbList ) )
{
rc = finalize( ref 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, ref 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( !Sql ){
// rc = SQLITE_NOMEM;
// goto next_exit;
//}
rc = sqlite3_prepare( pVtab.db, zSql, -1, ref 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,
string 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( ref pCur.pTableList );
finalize( ref pCur.pColumnList );
finalize( ref pCur.pDbList );
rc = sqlite3_prepare( pVtab.db, "PRAGMA database_list", -1, ref pCur.pDbList, 0 );
return ( rc == SQLITE_OK ? schemaNext( pVtabCursor ) : rc );
}
/*
** Analyse the WHERE condition.
*/
static int schemaBestIndex( sqlite3_vtab tab, ref sqlite3_index_info pIdxInfo )
{
return SQLITE_OK;
}
/*
** A virtual table module that merely echos method calls into TCL
** variables.
*/
static sqlite3_module schemaModule = new sqlite3_module(
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 */
null, /* xUpdate */
null, /* xBegin */
null, /* xSync */
null, /* xCommit */
null, /* xRollback */
null, /* xFindMethod */
null /* xRename */
);
#endif //* !defined(SQLITE_OMIT_VIRTUALTABLE) */
#if 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[] objv /* Command arguments */
)
{
sqlite3 db = null;
if ( objc != 2 )
{
TCL.Tcl_WrongNumArgs( interp, 1, objv, "DB" );
return TCL.TCL_ERROR;
}
if ( getDbPointer( interp, TCL.Tcl_GetString( objv[1] ), out db ) != 0 )
return TCL.TCL_ERROR;
#if !SQLITE_OMIT_VIRTUALTABLE
sqlite3_create_module( db, "schema", schemaModule, null );
#endif
return TCL.TCL_OK;
}
/*
** Register commands with the TCL interpreter.
*/
static public int Sqlitetestschema_Init( Tcl_Interp interp )
{
//static struct {
// char *zName;
// Tcl_ObjCmdProc *xProc;
// void *clientData;
//}
_aObjCmd[] aObjCmd = new _aObjCmd[]{
new _aObjCmd( "register_schema_module", register_schema_module, 0 ),
};
int i;
for ( i = 0; i < aObjCmd.Length; i++ )//sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++)
{
TCL.Tcl_CreateObjCommand( interp, aObjCmd[i].zName,
aObjCmd[i].xProc, aObjCmd[i].clientData, null );
}
return TCL.TCL_OK;
}
#else
/*
** Extension load function.
*/
int sqlite3_extension_init(
sqlite3 *db,
char **pzErrMsg,
const sqlite3_api_routines *pApi
){
SQLITE_EXTENSION_INIT2(pApi);
#if !SQLITE_OMIT_VIRTUALTABLE
sqlite3_create_module(db, "schema", &schemaModule, 0);
#endif
return 0;
}
#endif
}
#endif
}